Fix pg_upgrade to detect non-upgradable anyarray usages.

When we changed some built-in functions to use anycompatiblearray
instead of anyarray, we created a dump/restore hazard for user-defined
operators and aggregates relying on those functions: the user objects
have to be modified to change their signatures similarly.  This causes
pg_upgrade to fail partway through if the source installation contains
such objects.  We generally try to have pg_upgrade detect such hazards
and fail before it does anything exciting, so add logic to detect
this case too.

Back-patch to v14 where the change was made.

Justin Pryzby, reviewed by Andrey Borodin

Discussion: https://postgr.es/m/3383880.QJadu78ljV@vejsadalnx

diff --git a/src/bin/pg_upgrade/check.c b/src/bin/pg_upgrade/check.c
index ace7387edafd7f983d3d8ad42f9dbcf61e7b4e1b..332e13fd5758444f03adc2893eea8abb5462f9a5 100644 (file)
--- a/src/bin/pg_upgrade/check.c
+++ b/src/bin/pg_upgrade/check.c
@@ -24,6 +24,7 @@ static void check_proper_datallowconn(ClusterInfo *cluster);
 static void check_for_prepared_transactions(ClusterInfo *cluster);
 static void check_for_isn_and_int8_passing_mismatch(ClusterInfo *cluster);
 static void check_for_user_defined_postfix_ops(ClusterInfo *cluster);
+static void check_for_incompatible_polymorphics(ClusterInfo *cluster);
 static void check_for_tables_with_oids(ClusterInfo *cluster);
 static void check_for_composite_data_type_usage(ClusterInfo *cluster);
 static void check_for_reg_data_type_usage(ClusterInfo *cluster);
@@ -122,6 +123,13 @@ check_and_dump_old_cluster(bool live_check)
    if (GET_MAJOR_VERSION(old_cluster.major_version) <= 1300)
        check_for_user_defined_postfix_ops(&old_cluster);
 
+   /*
+    * PG 14 changed polymorphic functions from anyarray to
+    * anycompatiblearray.
+    */
+   if (GET_MAJOR_VERSION(old_cluster.major_version) <= 1300)
+       check_for_incompatible_polymorphics(&old_cluster);
+
    /*
     * Pre-PG 12 allowed tables to be declared WITH OIDS, which is not
     * supported anymore. Verify there are none, iff applicable.
@@ -999,6 +1007,133 @@ check_for_user_defined_postfix_ops(ClusterInfo *cluster)
        check_ok();
 }
 
+/*
+ * check_for_incompatible_polymorphics()
+ *
+ * Make sure nothing is using old polymorphic functions with
+ * anyarray/anyelement rather than the new anycompatible variants.
+ */
+static void
+check_for_incompatible_polymorphics(ClusterInfo *cluster)
+{
+   PGresult   *res;
+   FILE       *script = NULL;
+   char        output_path[MAXPGPATH];
+   PQExpBufferData old_polymorphics;
+
+   prep_status("Checking for incompatible polymorphic functions");
+
+   snprintf(output_path, sizeof(output_path), "%s/%s",
+            log_opts.basedir,
+            "incompatible_polymorphics.txt");
+
+   /* The set of problematic functions varies a bit in different versions */
+   initPQExpBuffer(&old_polymorphics);
+
+   appendPQExpBufferStr(&old_polymorphics,
+                        "'array_append(anyarray,anyelement)'"
+                        ", 'array_cat(anyarray,anyarray)'"
+                        ", 'array_prepend(anyelement,anyarray)'");
+
+   if (GET_MAJOR_VERSION(cluster->major_version) >= 903)
+       appendPQExpBufferStr(&old_polymorphics,
+                            ", 'array_remove(anyarray,anyelement)'"
+                            ", 'array_replace(anyarray,anyelement,anyelement)'");
+
+   if (GET_MAJOR_VERSION(cluster->major_version) >= 905)
+       appendPQExpBufferStr(&old_polymorphics,
+                            ", 'array_position(anyarray,anyelement)'"
+                            ", 'array_position(anyarray,anyelement,integer)'"
+                            ", 'array_positions(anyarray,anyelement)'"
+                            ", 'width_bucket(anyelement,anyarray)'");
+
+   for (int dbnum = 0; dbnum < cluster->dbarr.ndbs; dbnum++)
+   {
+       bool        db_used = false;
+       DbInfo     *active_db = &cluster->dbarr.dbs[dbnum];
+       PGconn     *conn = connectToServer(cluster, active_db->db_name);
+       int         ntups;
+       int         i_objkind,
+                   i_objname;
+
+       /*
+        * The query below hardcodes FirstNormalObjectId as 16384 rather than
+        * interpolating that C #define into the query because, if that
+        * #define is ever changed, the cutoff we want to use is the value
+        * used by pre-version 14 servers, not that of some future version.
+        */
+       res = executeQueryOrDie(conn,
+       /* Aggregate transition functions */
+                               "SELECT 'aggregate' AS objkind, p.oid::regprocedure::text AS objname "
+                               "FROM pg_proc AS p "
+                               "JOIN pg_aggregate AS a ON a.aggfnoid=p.oid "
+                               "JOIN pg_proc AS transfn ON transfn.oid=a.aggtransfn "
+                               "WHERE p.oid >= 16384 "
+                               "AND a.aggtransfn = ANY(ARRAY[%s]::regprocedure[]) "
+
+       /* Aggregate final functions */
+                               "UNION ALL "
+                               "SELECT 'aggregate' AS objkind, p.oid::regprocedure::text AS objname "
+                               "FROM pg_proc AS p "
+                               "JOIN pg_aggregate AS a ON a.aggfnoid=p.oid "
+                               "JOIN pg_proc AS finalfn ON finalfn.oid=a.aggfinalfn "
+                               "WHERE p.oid >= 16384 "
+                               "AND a.aggfinalfn = ANY(ARRAY[%s]::regprocedure[]) "
+
+       /* Operators */
+                               "UNION ALL "
+                               "SELECT 'operator' AS objkind, op.oid::regoperator::text AS objname "
+                               "FROM pg_operator AS op "
+                               "WHERE op.oid >= 16384 "
+                               "AND oprcode = ANY(ARRAY[%s]::regprocedure[]);",
+                               old_polymorphics.data,
+                               old_polymorphics.data,
+                               old_polymorphics.data);
+
+       ntups = PQntuples(res);
+
+       i_objkind = PQfnumber(res, "objkind");
+       i_objname = PQfnumber(res, "objname");
+
+       for (int rowno = 0; rowno < ntups; rowno++)
+       {
+           if (script == NULL &&
+               (script = fopen_priv(output_path, "w")) == NULL)
+               pg_fatal("could not open file \"%s\": %s\n",
+                        output_path, strerror(errno));
+           if (!db_used)
+           {
+               fprintf(script, "In database: %s\n", active_db->db_name);
+               db_used = true;
+           }
+
+           fprintf(script, "  %s: %s\n",
+                   PQgetvalue(res, rowno, i_objkind),
+                   PQgetvalue(res, rowno, i_objname));
+       }
+
+       PQclear(res);
+       PQfinish(conn);
+   }
+
+   if (script)
+   {
+       fclose(script);
+       pg_log(PG_REPORT, "fatal\n");
+       pg_fatal("Your installation contains user-defined objects that refer to internal\n"
+                "polymorphic functions with arguments of type 'anyarray' or 'anyelement'.\n"
+                "These user-defined objects must be dropped before upgrading and restored\n"
+                "afterwards, changing them to refer to the new corresponding functions with\n"
+                "arguments of type 'anycompatiblearray' and 'anycompatible'.\n"
+                "A list of the problematic objects is in the file:\n"
+                "    %s\n\n", output_path);
+   }
+   else
+       check_ok();
+
+   termPQExpBuffer(&old_polymorphics);
+}
+
 /*
  * Verify that no tables are declared WITH OIDS.
  */