2010-05-12 04:19:11 +02:00
|
|
|
/*
|
|
|
|
* check.c
|
|
|
|
*
|
|
|
|
* server checks and output routines
|
2010-07-03 16:23:14 +02:00
|
|
|
*
|
2014-01-07 22:05:30 +01:00
|
|
|
* Copyright (c) 2010-2014, PostgreSQL Global Development Group
|
2010-09-20 22:08:53 +02:00
|
|
|
* contrib/pg_upgrade/check.c
|
2010-05-12 04:19:11 +02:00
|
|
|
*/
|
|
|
|
|
Create libpgcommon, and move pg_malloc et al to it
libpgcommon is a new static library to allow sharing code among the
various frontend programs and backend; this lets us eliminate duplicate
implementations of common routines. We avoid libpgport, because that's
intended as a place for porting issues; per discussion, it seems better
to keep them separate.
The first use case, and the only implemented by this patch, is pg_malloc
and friends, which many frontend programs were already using.
At the same time, we can use this to provide palloc emulation functions
for the frontend; this way, some palloc-using files in the backend can
also be used by the frontend cleanly. To do this, we change palloc() in
the backend to be a function instead of a macro on top of
MemoryContextAlloc(). This was previously believed to cause loss of
performance, but this implementation has been tweaked by Tom and Andres
so that on modern compilers it provides a slight improvement over the
previous one.
This lets us clean up some places that were already with
localized hacks.
Most of the pg_malloc/palloc changes in this patch were authored by
Andres Freund. Zoltán Böszörményi also independently provided a form of
that. libpgcommon infrastructure was authored by Álvaro.
2013-02-12 14:33:40 +01:00
|
|
|
#include "postgres_fe.h"
|
2011-08-27 03:16:24 +02:00
|
|
|
|
2014-08-04 17:56:16 +02:00
|
|
|
#include "catalog/pg_authid.h"
|
Be forgiving of variant spellings of locale names in pg_upgrade.
Even though the server tries to canonicalize stored locale names, the
platform often doesn't cooperate, so it's entirely possible that one DB
thinks its locale is, say, "en_US.UTF-8" while the other has "en_US.utf8".
Rather than failing, we should try to allow this where it's clearly OK.
There is already pretty robust encoding lookup in encnames.c, so make
use of that to compare the encoding parts of the names. The locale
identifier parts are just compared case-insensitively, which we were
already doing. The major problem known to exist in the field is variant
encoding-name spellings, so hopefully this will be Good Enough. If not,
we can try being even laxer.
Pavel Raiskup, reviewed by Rushabh Lathia
2014-01-31 01:07:06 +01:00
|
|
|
#include "mb/pg_wchar.h"
|
2010-05-12 04:19:11 +02:00
|
|
|
#include "pg_upgrade.h"
|
|
|
|
|
|
|
|
|
2011-04-20 03:00:29 +02:00
|
|
|
static void check_new_cluster_is_empty(void);
|
Change the way encoding and locale checks are done in pg_upgrade.
Lc_collate and lc_ctype have been per-database settings since server version
8.4, but pg_upgrade was still treating them as cluster-wide options. It
fetched the values for the template0 databases in old and new cluster, and
compared them. That's backwards; the encoding and locale of the template0
database doesn't matter, as template0 is guaranteed to contain only ASCII
characters. But if there are any other databases that exist on both clusters
(in particular template1 and postgres databases), their encodings and
locales must be compatible.
Also, make the locale comparison more lenient. If the locale names are not
equal, try to canonicalize both of them by passing them to setlocale(). We
used to do that only when upgrading from 9.1 or below, but it seems like a
good idea even with newer versions. If we change the canonical form of a
locale, this allows pg_upgrade to still work. I'm about to do just that to
fix bug #11431, by mapping a locale name that contains non-ASCII characters
to a pure-ASCII alias of the same locale.
No backpatching, because earlier versions of pg_upgrade still support
upgrading from 8.3 servers. That would be more complicated, so it doesn't
seem worth it, given that we haven't received any complaints about this
from users.
2014-10-10 08:59:44 +02:00
|
|
|
static void check_databases_are_compatible(void);
|
|
|
|
static void check_locale_and_encoding(DbInfo *olddb, DbInfo *newdb);
|
|
|
|
static bool equivalent_locale(int category, const char *loca, const char *locb);
|
2014-08-04 17:56:16 +02:00
|
|
|
static void check_is_install_user(ClusterInfo *cluster);
|
2011-06-14 20:53:35 +02:00
|
|
|
static void check_for_prepared_transactions(ClusterInfo *cluster);
|
2011-01-01 18:06:36 +01:00
|
|
|
static void check_for_isn_and_int8_passing_mismatch(ClusterInfo *cluster);
|
|
|
|
static void check_for_reg_data_type_usage(ClusterInfo *cluster);
|
2014-09-30 02:19:59 +02:00
|
|
|
static void check_for_jsonb_9_4_usage(ClusterInfo *cluster);
|
2011-06-23 02:48:34 +02:00
|
|
|
static void get_bin_version(ClusterInfo *cluster);
|
2012-10-02 17:42:34 +02:00
|
|
|
static char *get_canonical_locale_name(int category, const char *locale);
|
2010-05-12 04:19:11 +02:00
|
|
|
|
|
|
|
|
2012-09-04 00:06:47 +02:00
|
|
|
/*
|
|
|
|
* fix_path_separator
|
|
|
|
* For non-Windows, just return the argument.
|
|
|
|
* For Windows convert any forward slash to a backslash
|
2013-05-29 22:58:43 +02:00
|
|
|
* such as is suitable for arguments to builtin commands
|
2012-09-04 00:06:47 +02:00
|
|
|
* like RMDIR and DEL.
|
|
|
|
*/
|
2012-09-04 04:59:19 +02:00
|
|
|
static char *
|
|
|
|
fix_path_separator(char *path)
|
2012-09-04 00:06:47 +02:00
|
|
|
{
|
|
|
|
#ifdef WIN32
|
|
|
|
|
2013-05-29 22:58:43 +02:00
|
|
|
char *result;
|
|
|
|
char *c;
|
2012-09-04 00:06:47 +02:00
|
|
|
|
|
|
|
result = pg_strdup(path);
|
|
|
|
|
|
|
|
for (c = result; *c != '\0'; c++)
|
|
|
|
if (*c == '/')
|
|
|
|
*c = '\\';
|
|
|
|
|
|
|
|
return result;
|
|
|
|
#else
|
|
|
|
|
|
|
|
return path;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2010-05-12 04:19:11 +02:00
|
|
|
void
|
2013-01-24 21:20:11 +01:00
|
|
|
output_check_banner(bool live_check)
|
2010-05-12 04:19:11 +02:00
|
|
|
{
|
2013-01-24 21:20:11 +01:00
|
|
|
if (user_opts.check && live_check)
|
2010-05-12 04:19:11 +02:00
|
|
|
{
|
2011-06-22 20:48:59 +02:00
|
|
|
pg_log(PG_REPORT, "Performing Consistency Checks on Old Live Server\n");
|
2010-10-19 23:38:16 +02:00
|
|
|
pg_log(PG_REPORT, "------------------------------------------------\n");
|
2010-05-12 04:19:11 +02:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2010-10-19 23:38:16 +02:00
|
|
|
pg_log(PG_REPORT, "Performing Consistency Checks\n");
|
|
|
|
pg_log(PG_REPORT, "-----------------------------\n");
|
2010-05-12 04:19:11 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void
|
2014-08-26 02:05:07 +02:00
|
|
|
check_and_dump_old_cluster(bool live_check)
|
2010-05-12 04:19:11 +02:00
|
|
|
{
|
|
|
|
/* -- OLD -- */
|
|
|
|
|
|
|
|
if (!live_check)
|
2013-01-24 21:20:11 +01:00
|
|
|
start_postmaster(&old_cluster, true);
|
2010-05-12 04:19:11 +02:00
|
|
|
|
2011-01-01 18:06:36 +01:00
|
|
|
get_pg_database_relfilenode(&old_cluster);
|
2010-05-12 04:19:11 +02:00
|
|
|
|
|
|
|
/* Extract a list of databases and tables from the old cluster */
|
2011-01-01 18:06:36 +01:00
|
|
|
get_db_and_rel_infos(&old_cluster);
|
2010-05-12 04:19:11 +02:00
|
|
|
|
2010-10-19 23:38:16 +02:00
|
|
|
init_tablespaces();
|
2010-05-12 04:19:11 +02:00
|
|
|
|
2010-10-19 23:38:16 +02:00
|
|
|
get_loadable_libraries();
|
2010-05-12 04:19:11 +02:00
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Check for various failure cases
|
|
|
|
*/
|
2014-08-04 17:56:16 +02:00
|
|
|
check_is_install_user(&old_cluster);
|
2011-06-14 20:53:35 +02:00
|
|
|
check_for_prepared_transactions(&old_cluster);
|
2011-01-01 18:06:36 +01:00
|
|
|
check_for_reg_data_type_usage(&old_cluster);
|
|
|
|
check_for_isn_and_int8_passing_mismatch(&old_cluster);
|
2014-09-30 02:19:59 +02:00
|
|
|
if (GET_MAJOR_VERSION(old_cluster.major_version) == 904 &&
|
|
|
|
old_cluster.controldata.cat_ver < JSONB_FORMAT_CHANGE_CAT_VER)
|
|
|
|
check_for_jsonb_9_4_usage(&old_cluster);
|
2010-05-12 04:19:11 +02:00
|
|
|
|
2014-05-14 22:26:06 +02:00
|
|
|
/* Pre-PG 9.4 had a different 'line' data type internal format */
|
2014-05-15 03:13:59 +02:00
|
|
|
if (GET_MAJOR_VERSION(old_cluster.major_version) <= 903)
|
2014-05-14 22:26:06 +02:00
|
|
|
old_9_3_check_for_line_data_type_usage(&old_cluster);
|
|
|
|
|
2010-05-12 04:19:11 +02:00
|
|
|
/* Pre-PG 9.0 had no large object permissions */
|
2010-10-19 23:38:16 +02:00
|
|
|
if (GET_MAJOR_VERSION(old_cluster.major_version) <= 804)
|
2011-01-01 18:06:36 +01:00
|
|
|
new_9_0_populate_pg_largeobject_metadata(&old_cluster, true);
|
2010-05-12 04:19:11 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* While not a check option, we do this now because this is the only time
|
|
|
|
* the old server is running.
|
|
|
|
*/
|
2010-10-19 23:38:16 +02:00
|
|
|
if (!user_opts.check)
|
|
|
|
generate_old_dump();
|
2010-05-12 04:19:11 +02:00
|
|
|
|
|
|
|
if (!live_check)
|
2011-04-26 02:17:48 +02:00
|
|
|
stop_postmaster(false);
|
2010-05-12 04:19:11 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void
|
2010-10-19 23:38:16 +02:00
|
|
|
check_new_cluster(void)
|
2010-05-12 04:19:11 +02:00
|
|
|
{
|
2011-04-20 03:00:29 +02:00
|
|
|
get_db_and_rel_infos(&new_cluster);
|
|
|
|
|
|
|
|
check_new_cluster_is_empty();
|
Change the way encoding and locale checks are done in pg_upgrade.
Lc_collate and lc_ctype have been per-database settings since server version
8.4, but pg_upgrade was still treating them as cluster-wide options. It
fetched the values for the template0 databases in old and new cluster, and
compared them. That's backwards; the encoding and locale of the template0
database doesn't matter, as template0 is guaranteed to contain only ASCII
characters. But if there are any other databases that exist on both clusters
(in particular template1 and postgres databases), their encodings and
locales must be compatible.
Also, make the locale comparison more lenient. If the locale names are not
equal, try to canonicalize both of them by passing them to setlocale(). We
used to do that only when upgrading from 9.1 or below, but it seems like a
good idea even with newer versions. If we change the canonical form of a
locale, this allows pg_upgrade to still work. I'm about to do just that to
fix bug #11431, by mapping a locale name that contains non-ASCII characters
to a pure-ASCII alias of the same locale.
No backpatching, because earlier versions of pg_upgrade still support
upgrading from 8.3 servers. That would be more complicated, so it doesn't
seem worth it, given that we haven't received any complaints about this
from users.
2014-10-10 08:59:44 +02:00
|
|
|
check_databases_are_compatible();
|
2010-05-12 04:19:11 +02:00
|
|
|
|
2010-10-19 23:38:16 +02:00
|
|
|
check_loadable_libraries();
|
2010-05-12 04:19:11 +02:00
|
|
|
|
2010-10-19 23:38:16 +02:00
|
|
|
if (user_opts.transfer_mode == TRANSFER_MODE_LINK)
|
|
|
|
check_hard_link();
|
2012-06-13 18:19:18 +02:00
|
|
|
|
2014-08-04 17:56:16 +02:00
|
|
|
check_is_install_user(&new_cluster);
|
2013-05-29 22:58:43 +02:00
|
|
|
|
2012-06-13 18:19:18 +02:00
|
|
|
check_for_prepared_transactions(&new_cluster);
|
2010-05-12 04:19:11 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void
|
2010-10-19 23:38:16 +02:00
|
|
|
report_clusters_compatible(void)
|
2010-05-12 04:19:11 +02:00
|
|
|
{
|
2010-10-19 23:38:16 +02:00
|
|
|
if (user_opts.check)
|
2010-05-12 04:19:11 +02:00
|
|
|
{
|
2010-10-19 23:38:16 +02:00
|
|
|
pg_log(PG_REPORT, "\n*Clusters are compatible*\n");
|
2010-05-12 04:19:11 +02:00
|
|
|
/* stops new cluster */
|
2011-04-26 02:17:48 +02:00
|
|
|
stop_postmaster(false);
|
2011-04-06 22:00:44 +02:00
|
|
|
exit(0);
|
2010-05-12 04:19:11 +02:00
|
|
|
}
|
|
|
|
|
2010-10-19 23:38:16 +02:00
|
|
|
pg_log(PG_REPORT, "\n"
|
2012-03-06 03:19:54 +01:00
|
|
|
"If pg_upgrade fails after this point, you must re-initdb the\n"
|
|
|
|
"new cluster before continuing.\n");
|
2010-05-12 04:19:11 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void
|
2014-08-26 02:05:07 +02:00
|
|
|
issue_warnings(void)
|
2010-05-12 04:19:11 +02:00
|
|
|
{
|
|
|
|
/* Create dummy large object permissions for old < PG 9.0? */
|
2010-10-19 23:38:16 +02:00
|
|
|
if (GET_MAJOR_VERSION(old_cluster.major_version) <= 804)
|
2010-05-12 04:19:11 +02:00
|
|
|
{
|
2013-01-24 21:20:11 +01:00
|
|
|
start_postmaster(&new_cluster, true);
|
2011-01-01 18:06:36 +01:00
|
|
|
new_9_0_populate_pg_largeobject_metadata(&new_cluster, false);
|
2011-04-26 02:17:48 +02:00
|
|
|
stop_postmaster(false);
|
2010-05-12 04:19:11 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void
|
2012-03-16 23:54:11 +01:00
|
|
|
output_completion_banner(char *analyze_script_file_name,
|
|
|
|
char *deletion_script_file_name)
|
2010-05-12 04:19:11 +02:00
|
|
|
{
|
2010-12-15 13:11:31 +01:00
|
|
|
/* Did we copy the free space files? */
|
2010-10-19 23:38:16 +02:00
|
|
|
if (GET_MAJOR_VERSION(old_cluster.major_version) >= 804)
|
|
|
|
pg_log(PG_REPORT,
|
2012-03-16 23:54:11 +01:00
|
|
|
"Optimizer statistics are not transferred by pg_upgrade so,\n"
|
|
|
|
"once you start the new server, consider running:\n"
|
|
|
|
" %s\n\n", analyze_script_file_name);
|
2010-05-12 04:19:11 +02:00
|
|
|
else
|
2010-10-19 23:38:16 +02:00
|
|
|
pg_log(PG_REPORT,
|
2011-07-12 06:13:51 +02:00
|
|
|
"Optimizer statistics and free space information are not transferred\n"
|
2012-06-10 21:20:04 +02:00
|
|
|
"by pg_upgrade so, once you start the new server, consider running:\n"
|
2012-03-16 23:54:11 +01:00
|
|
|
" %s\n\n", analyze_script_file_name);
|
2010-05-12 04:19:11 +02:00
|
|
|
|
2013-02-14 16:53:03 +01:00
|
|
|
|
|
|
|
if (deletion_script_file_name)
|
|
|
|
pg_log(PG_REPORT,
|
2013-05-29 22:58:43 +02:00
|
|
|
"Running this script will delete the old cluster's data files:\n"
|
2013-02-14 16:53:03 +01:00
|
|
|
" %s\n",
|
|
|
|
deletion_script_file_name);
|
|
|
|
else
|
|
|
|
pg_log(PG_REPORT,
|
|
|
|
"Could not create a script to delete the old cluster's data\n"
|
2013-05-29 22:58:43 +02:00
|
|
|
"files because user-defined tablespaces exist in the old cluster\n"
|
|
|
|
"directory. The old cluster's contents must be deleted manually.\n");
|
2010-05-12 04:19:11 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void
|
2010-10-19 23:38:16 +02:00
|
|
|
check_cluster_versions(void)
|
2010-05-12 04:19:11 +02:00
|
|
|
{
|
2011-06-23 02:48:34 +02:00
|
|
|
prep_status("Checking cluster versions");
|
|
|
|
|
2010-05-12 04:19:11 +02:00
|
|
|
/* get old and new cluster versions */
|
2011-01-01 18:28:48 +01:00
|
|
|
old_cluster.major_version = get_major_server_version(&old_cluster);
|
|
|
|
new_cluster.major_version = get_major_server_version(&new_cluster);
|
2010-05-12 04:19:11 +02:00
|
|
|
|
2011-04-10 17:42:00 +02:00
|
|
|
/*
|
|
|
|
* We allow upgrades from/to the same major version for alpha/beta
|
|
|
|
* upgrades
|
|
|
|
*/
|
2010-05-12 04:19:11 +02:00
|
|
|
|
2014-08-26 02:05:07 +02:00
|
|
|
if (GET_MAJOR_VERSION(old_cluster.major_version) < 804)
|
|
|
|
pg_fatal("This utility can only upgrade from PostgreSQL version 8.4 and later.\n");
|
2010-05-12 04:19:11 +02:00
|
|
|
|
|
|
|
/* Only current PG version is supported as a target */
|
2010-10-19 23:38:16 +02:00
|
|
|
if (GET_MAJOR_VERSION(new_cluster.major_version) != GET_MAJOR_VERSION(PG_VERSION_NUM))
|
2013-10-02 03:24:56 +02:00
|
|
|
pg_fatal("This utility can only upgrade to PostgreSQL version %s.\n",
|
2014-05-06 18:12:18 +02:00
|
|
|
PG_MAJORVERSION);
|
2010-05-12 04:19:11 +02:00
|
|
|
|
|
|
|
/*
|
2014-07-01 01:55:55 +02:00
|
|
|
* We can't allow downgrading because we use the target pg_dump, and
|
|
|
|
* pg_dump cannot operate on newer database versions, only current and
|
|
|
|
* older versions.
|
2010-05-12 04:19:11 +02:00
|
|
|
*/
|
2010-10-19 23:38:16 +02:00
|
|
|
if (old_cluster.major_version > new_cluster.major_version)
|
2013-10-02 03:24:56 +02:00
|
|
|
pg_fatal("This utility cannot be used to downgrade to older major PostgreSQL versions.\n");
|
2011-06-23 02:48:34 +02:00
|
|
|
|
|
|
|
/* get old and new binary versions */
|
|
|
|
get_bin_version(&old_cluster);
|
|
|
|
get_bin_version(&new_cluster);
|
|
|
|
|
|
|
|
/* Ensure binaries match the designated data directories */
|
|
|
|
if (GET_MAJOR_VERSION(old_cluster.major_version) !=
|
|
|
|
GET_MAJOR_VERSION(old_cluster.bin_version))
|
2013-10-02 03:24:56 +02:00
|
|
|
pg_fatal("Old cluster data and binary directories are from different major versions.\n");
|
2011-06-23 02:48:34 +02:00
|
|
|
if (GET_MAJOR_VERSION(new_cluster.major_version) !=
|
|
|
|
GET_MAJOR_VERSION(new_cluster.bin_version))
|
2013-10-02 03:24:56 +02:00
|
|
|
pg_fatal("New cluster data and binary directories are from different major versions.\n");
|
2011-06-23 02:48:34 +02:00
|
|
|
|
|
|
|
check_ok();
|
2010-05-12 04:19:11 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void
|
2010-10-19 23:38:16 +02:00
|
|
|
check_cluster_compatibility(bool live_check)
|
2010-05-12 04:19:11 +02:00
|
|
|
{
|
|
|
|
/* get/check pg_control data of servers */
|
2010-10-19 23:38:16 +02:00
|
|
|
get_control_data(&old_cluster, live_check);
|
|
|
|
get_control_data(&new_cluster, false);
|
|
|
|
check_control_data(&old_cluster.controldata, &new_cluster.controldata);
|
2010-05-12 04:19:11 +02:00
|
|
|
|
|
|
|
/* Is it 9.0 but without tablespace directories? */
|
2010-10-19 23:38:16 +02:00
|
|
|
if (GET_MAJOR_VERSION(new_cluster.major_version) == 900 &&
|
2011-04-25 18:00:21 +02:00
|
|
|
new_cluster.controldata.cat_ver < TABLE_SPACE_SUBDIRS_CAT_VER)
|
2013-10-02 03:24:56 +02:00
|
|
|
pg_fatal("This utility can only upgrade to PostgreSQL version 9.0 after 2010-01-11\n"
|
2014-05-06 18:12:18 +02:00
|
|
|
"because of backend API changes made during development.\n");
|
2012-09-04 04:15:09 +02:00
|
|
|
|
|
|
|
/* We read the real port number for PG >= 9.1 */
|
|
|
|
if (live_check && GET_MAJOR_VERSION(old_cluster.major_version) < 901 &&
|
|
|
|
old_cluster.port == DEF_PGUPORT)
|
2013-10-02 03:24:56 +02:00
|
|
|
pg_fatal("When checking a pre-PG 9.1 live old server, "
|
2014-05-06 18:12:18 +02:00
|
|
|
"you must specify the old server's port number.\n");
|
2012-09-04 04:15:09 +02:00
|
|
|
|
|
|
|
if (live_check && old_cluster.port == new_cluster.port)
|
2013-10-02 03:24:56 +02:00
|
|
|
pg_fatal("When checking a live server, "
|
2014-05-06 18:12:18 +02:00
|
|
|
"the old and new port numbers must be different.\n");
|
2010-05-12 04:19:11 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* check_locale_and_encoding()
|
|
|
|
*
|
Change the way encoding and locale checks are done in pg_upgrade.
Lc_collate and lc_ctype have been per-database settings since server version
8.4, but pg_upgrade was still treating them as cluster-wide options. It
fetched the values for the template0 databases in old and new cluster, and
compared them. That's backwards; the encoding and locale of the template0
database doesn't matter, as template0 is guaranteed to contain only ASCII
characters. But if there are any other databases that exist on both clusters
(in particular template1 and postgres databases), their encodings and
locales must be compatible.
Also, make the locale comparison more lenient. If the locale names are not
equal, try to canonicalize both of them by passing them to setlocale(). We
used to do that only when upgrading from 9.1 or below, but it seems like a
good idea even with newer versions. If we change the canonical form of a
locale, this allows pg_upgrade to still work. I'm about to do just that to
fix bug #11431, by mapping a locale name that contains non-ASCII characters
to a pure-ASCII alias of the same locale.
No backpatching, because earlier versions of pg_upgrade still support
upgrading from 8.3 servers. That would be more complicated, so it doesn't
seem worth it, given that we haven't received any complaints about this
from users.
2014-10-10 08:59:44 +02:00
|
|
|
* Check that locale and encoding of a database in the old and new clusters
|
|
|
|
* are compatible.
|
2010-05-12 04:19:11 +02:00
|
|
|
*/
|
|
|
|
static void
|
Change the way encoding and locale checks are done in pg_upgrade.
Lc_collate and lc_ctype have been per-database settings since server version
8.4, but pg_upgrade was still treating them as cluster-wide options. It
fetched the values for the template0 databases in old and new cluster, and
compared them. That's backwards; the encoding and locale of the template0
database doesn't matter, as template0 is guaranteed to contain only ASCII
characters. But if there are any other databases that exist on both clusters
(in particular template1 and postgres databases), their encodings and
locales must be compatible.
Also, make the locale comparison more lenient. If the locale names are not
equal, try to canonicalize both of them by passing them to setlocale(). We
used to do that only when upgrading from 9.1 or below, but it seems like a
good idea even with newer versions. If we change the canonical form of a
locale, this allows pg_upgrade to still work. I'm about to do just that to
fix bug #11431, by mapping a locale name that contains non-ASCII characters
to a pure-ASCII alias of the same locale.
No backpatching, because earlier versions of pg_upgrade still support
upgrading from 8.3 servers. That would be more complicated, so it doesn't
seem worth it, given that we haven't received any complaints about this
from users.
2014-10-10 08:59:44 +02:00
|
|
|
check_locale_and_encoding(DbInfo *olddb, DbInfo *newdb)
|
2010-05-12 04:19:11 +02:00
|
|
|
{
|
Change the way encoding and locale checks are done in pg_upgrade.
Lc_collate and lc_ctype have been per-database settings since server version
8.4, but pg_upgrade was still treating them as cluster-wide options. It
fetched the values for the template0 databases in old and new cluster, and
compared them. That's backwards; the encoding and locale of the template0
database doesn't matter, as template0 is guaranteed to contain only ASCII
characters. But if there are any other databases that exist on both clusters
(in particular template1 and postgres databases), their encodings and
locales must be compatible.
Also, make the locale comparison more lenient. If the locale names are not
equal, try to canonicalize both of them by passing them to setlocale(). We
used to do that only when upgrading from 9.1 or below, but it seems like a
good idea even with newer versions. If we change the canonical form of a
locale, this allows pg_upgrade to still work. I'm about to do just that to
fix bug #11431, by mapping a locale name that contains non-ASCII characters
to a pure-ASCII alias of the same locale.
No backpatching, because earlier versions of pg_upgrade still support
upgrading from 8.3 servers. That would be more complicated, so it doesn't
seem worth it, given that we haven't received any complaints about this
from users.
2014-10-10 08:59:44 +02:00
|
|
|
if (olddb->db_encoding != newdb->db_encoding)
|
|
|
|
pg_fatal("encodings for database \"%s\" do not match: old \"%s\", new \"%s\"\n",
|
|
|
|
olddb->db_name,
|
|
|
|
pg_encoding_to_char(olddb->db_encoding),
|
|
|
|
pg_encoding_to_char(newdb->db_encoding));
|
|
|
|
if (!equivalent_locale(LC_COLLATE, olddb->db_collate, newdb->db_collate))
|
|
|
|
pg_fatal("lc_collate values for database \"%s\" do not match: old \"%s\", new \"%s\"\n",
|
|
|
|
olddb->db_name, olddb->db_collate, newdb->db_collate);
|
|
|
|
if (!equivalent_locale(LC_CTYPE, olddb->db_ctype, newdb->db_ctype))
|
|
|
|
pg_fatal("lc_ctype values for database \"%s\" do not match: old \"%s\", new \"%s\"\n",
|
|
|
|
olddb->db_name, olddb->db_ctype, newdb->db_ctype);
|
Be forgiving of variant spellings of locale names in pg_upgrade.
Even though the server tries to canonicalize stored locale names, the
platform often doesn't cooperate, so it's entirely possible that one DB
thinks its locale is, say, "en_US.UTF-8" while the other has "en_US.utf8".
Rather than failing, we should try to allow this where it's clearly OK.
There is already pretty robust encoding lookup in encnames.c, so make
use of that to compare the encoding parts of the names. The locale
identifier parts are just compared case-insensitively, which we were
already doing. The major problem known to exist in the field is variant
encoding-name spellings, so hopefully this will be Good Enough. If not,
we can try being even laxer.
Pavel Raiskup, reviewed by Rushabh Lathia
2014-01-31 01:07:06 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* equivalent_locale()
|
|
|
|
*
|
|
|
|
* Best effort locale-name comparison. Return false if we are not 100% sure
|
|
|
|
* the locales are equivalent.
|
Change the way encoding and locale checks are done in pg_upgrade.
Lc_collate and lc_ctype have been per-database settings since server version
8.4, but pg_upgrade was still treating them as cluster-wide options. It
fetched the values for the template0 databases in old and new cluster, and
compared them. That's backwards; the encoding and locale of the template0
database doesn't matter, as template0 is guaranteed to contain only ASCII
characters. But if there are any other databases that exist on both clusters
(in particular template1 and postgres databases), their encodings and
locales must be compatible.
Also, make the locale comparison more lenient. If the locale names are not
equal, try to canonicalize both of them by passing them to setlocale(). We
used to do that only when upgrading from 9.1 or below, but it seems like a
good idea even with newer versions. If we change the canonical form of a
locale, this allows pg_upgrade to still work. I'm about to do just that to
fix bug #11431, by mapping a locale name that contains non-ASCII characters
to a pure-ASCII alias of the same locale.
No backpatching, because earlier versions of pg_upgrade still support
upgrading from 8.3 servers. That would be more complicated, so it doesn't
seem worth it, given that we haven't received any complaints about this
from users.
2014-10-10 08:59:44 +02:00
|
|
|
*
|
|
|
|
* Note: The encoding parts of the names are ignored. This function is
|
|
|
|
* currently used to compare locale names stored in pg_database, and
|
|
|
|
* pg_database contains a separate encoding field. That's compared directly
|
|
|
|
* in check_locale_and_encoding().
|
Be forgiving of variant spellings of locale names in pg_upgrade.
Even though the server tries to canonicalize stored locale names, the
platform often doesn't cooperate, so it's entirely possible that one DB
thinks its locale is, say, "en_US.UTF-8" while the other has "en_US.utf8".
Rather than failing, we should try to allow this where it's clearly OK.
There is already pretty robust encoding lookup in encnames.c, so make
use of that to compare the encoding parts of the names. The locale
identifier parts are just compared case-insensitively, which we were
already doing. The major problem known to exist in the field is variant
encoding-name spellings, so hopefully this will be Good Enough. If not,
we can try being even laxer.
Pavel Raiskup, reviewed by Rushabh Lathia
2014-01-31 01:07:06 +01:00
|
|
|
*/
|
|
|
|
static bool
|
Change the way encoding and locale checks are done in pg_upgrade.
Lc_collate and lc_ctype have been per-database settings since server version
8.4, but pg_upgrade was still treating them as cluster-wide options. It
fetched the values for the template0 databases in old and new cluster, and
compared them. That's backwards; the encoding and locale of the template0
database doesn't matter, as template0 is guaranteed to contain only ASCII
characters. But if there are any other databases that exist on both clusters
(in particular template1 and postgres databases), their encodings and
locales must be compatible.
Also, make the locale comparison more lenient. If the locale names are not
equal, try to canonicalize both of them by passing them to setlocale(). We
used to do that only when upgrading from 9.1 or below, but it seems like a
good idea even with newer versions. If we change the canonical form of a
locale, this allows pg_upgrade to still work. I'm about to do just that to
fix bug #11431, by mapping a locale name that contains non-ASCII characters
to a pure-ASCII alias of the same locale.
No backpatching, because earlier versions of pg_upgrade still support
upgrading from 8.3 servers. That would be more complicated, so it doesn't
seem worth it, given that we haven't received any complaints about this
from users.
2014-10-10 08:59:44 +02:00
|
|
|
equivalent_locale(int category, const char *loca, const char *locb)
|
Be forgiving of variant spellings of locale names in pg_upgrade.
Even though the server tries to canonicalize stored locale names, the
platform often doesn't cooperate, so it's entirely possible that one DB
thinks its locale is, say, "en_US.UTF-8" while the other has "en_US.utf8".
Rather than failing, we should try to allow this where it's clearly OK.
There is already pretty robust encoding lookup in encnames.c, so make
use of that to compare the encoding parts of the names. The locale
identifier parts are just compared case-insensitively, which we were
already doing. The major problem known to exist in the field is variant
encoding-name spellings, so hopefully this will be Good Enough. If not,
we can try being even laxer.
Pavel Raiskup, reviewed by Rushabh Lathia
2014-01-31 01:07:06 +01:00
|
|
|
{
|
2014-10-10 12:00:53 +02:00
|
|
|
const char *chara;
|
|
|
|
const char *charb;
|
Change the way encoding and locale checks are done in pg_upgrade.
Lc_collate and lc_ctype have been per-database settings since server version
8.4, but pg_upgrade was still treating them as cluster-wide options. It
fetched the values for the template0 databases in old and new cluster, and
compared them. That's backwards; the encoding and locale of the template0
database doesn't matter, as template0 is guaranteed to contain only ASCII
characters. But if there are any other databases that exist on both clusters
(in particular template1 and postgres databases), their encodings and
locales must be compatible.
Also, make the locale comparison more lenient. If the locale names are not
equal, try to canonicalize both of them by passing them to setlocale(). We
used to do that only when upgrading from 9.1 or below, but it seems like a
good idea even with newer versions. If we change the canonical form of a
locale, this allows pg_upgrade to still work. I'm about to do just that to
fix bug #11431, by mapping a locale name that contains non-ASCII characters
to a pure-ASCII alias of the same locale.
No backpatching, because earlier versions of pg_upgrade still support
upgrading from 8.3 servers. That would be more complicated, so it doesn't
seem worth it, given that we haven't received any complaints about this
from users.
2014-10-10 08:59:44 +02:00
|
|
|
char *canona;
|
|
|
|
char *canonb;
|
|
|
|
int lena;
|
|
|
|
int lenb;
|
Be forgiving of variant spellings of locale names in pg_upgrade.
Even though the server tries to canonicalize stored locale names, the
platform often doesn't cooperate, so it's entirely possible that one DB
thinks its locale is, say, "en_US.UTF-8" while the other has "en_US.utf8".
Rather than failing, we should try to allow this where it's clearly OK.
There is already pretty robust encoding lookup in encnames.c, so make
use of that to compare the encoding parts of the names. The locale
identifier parts are just compared case-insensitively, which we were
already doing. The major problem known to exist in the field is variant
encoding-name spellings, so hopefully this will be Good Enough. If not,
we can try being even laxer.
Pavel Raiskup, reviewed by Rushabh Lathia
2014-01-31 01:07:06 +01:00
|
|
|
|
2014-01-31 08:03:30 +01:00
|
|
|
/*
|
Change the way encoding and locale checks are done in pg_upgrade.
Lc_collate and lc_ctype have been per-database settings since server version
8.4, but pg_upgrade was still treating them as cluster-wide options. It
fetched the values for the template0 databases in old and new cluster, and
compared them. That's backwards; the encoding and locale of the template0
database doesn't matter, as template0 is guaranteed to contain only ASCII
characters. But if there are any other databases that exist on both clusters
(in particular template1 and postgres databases), their encodings and
locales must be compatible.
Also, make the locale comparison more lenient. If the locale names are not
equal, try to canonicalize both of them by passing them to setlocale(). We
used to do that only when upgrading from 9.1 or below, but it seems like a
good idea even with newer versions. If we change the canonical form of a
locale, this allows pg_upgrade to still work. I'm about to do just that to
fix bug #11431, by mapping a locale name that contains non-ASCII characters
to a pure-ASCII alias of the same locale.
No backpatching, because earlier versions of pg_upgrade still support
upgrading from 8.3 servers. That would be more complicated, so it doesn't
seem worth it, given that we haven't received any complaints about this
from users.
2014-10-10 08:59:44 +02:00
|
|
|
* If the names are equal, the locales are equivalent. Checking this
|
|
|
|
* first avoids calling setlocale() in the common case that the names
|
|
|
|
* are equal. That's a good thing, if setlocale() is buggy, for example.
|
2014-01-31 08:03:30 +01:00
|
|
|
*/
|
Change the way encoding and locale checks are done in pg_upgrade.
Lc_collate and lc_ctype have been per-database settings since server version
8.4, but pg_upgrade was still treating them as cluster-wide options. It
fetched the values for the template0 databases in old and new cluster, and
compared them. That's backwards; the encoding and locale of the template0
database doesn't matter, as template0 is guaranteed to contain only ASCII
characters. But if there are any other databases that exist on both clusters
(in particular template1 and postgres databases), their encodings and
locales must be compatible.
Also, make the locale comparison more lenient. If the locale names are not
equal, try to canonicalize both of them by passing them to setlocale(). We
used to do that only when upgrading from 9.1 or below, but it seems like a
good idea even with newer versions. If we change the canonical form of a
locale, this allows pg_upgrade to still work. I'm about to do just that to
fix bug #11431, by mapping a locale name that contains non-ASCII characters
to a pure-ASCII alias of the same locale.
No backpatching, because earlier versions of pg_upgrade still support
upgrading from 8.3 servers. That would be more complicated, so it doesn't
seem worth it, given that we haven't received any complaints about this
from users.
2014-10-10 08:59:44 +02:00
|
|
|
if (pg_strcasecmp(loca, locb) == 0)
|
|
|
|
return true;
|
Be forgiving of variant spellings of locale names in pg_upgrade.
Even though the server tries to canonicalize stored locale names, the
platform often doesn't cooperate, so it's entirely possible that one DB
thinks its locale is, say, "en_US.UTF-8" while the other has "en_US.utf8".
Rather than failing, we should try to allow this where it's clearly OK.
There is already pretty robust encoding lookup in encnames.c, so make
use of that to compare the encoding parts of the names. The locale
identifier parts are just compared case-insensitively, which we were
already doing. The major problem known to exist in the field is variant
encoding-name spellings, so hopefully this will be Good Enough. If not,
we can try being even laxer.
Pavel Raiskup, reviewed by Rushabh Lathia
2014-01-31 01:07:06 +01:00
|
|
|
|
|
|
|
/*
|
Change the way encoding and locale checks are done in pg_upgrade.
Lc_collate and lc_ctype have been per-database settings since server version
8.4, but pg_upgrade was still treating them as cluster-wide options. It
fetched the values for the template0 databases in old and new cluster, and
compared them. That's backwards; the encoding and locale of the template0
database doesn't matter, as template0 is guaranteed to contain only ASCII
characters. But if there are any other databases that exist on both clusters
(in particular template1 and postgres databases), their encodings and
locales must be compatible.
Also, make the locale comparison more lenient. If the locale names are not
equal, try to canonicalize both of them by passing them to setlocale(). We
used to do that only when upgrading from 9.1 or below, but it seems like a
good idea even with newer versions. If we change the canonical form of a
locale, this allows pg_upgrade to still work. I'm about to do just that to
fix bug #11431, by mapping a locale name that contains non-ASCII characters
to a pure-ASCII alias of the same locale.
No backpatching, because earlier versions of pg_upgrade still support
upgrading from 8.3 servers. That would be more complicated, so it doesn't
seem worth it, given that we haven't received any complaints about this
from users.
2014-10-10 08:59:44 +02:00
|
|
|
* Not identical. Canonicalize both names, remove the encoding parts,
|
|
|
|
* and try again.
|
Be forgiving of variant spellings of locale names in pg_upgrade.
Even though the server tries to canonicalize stored locale names, the
platform often doesn't cooperate, so it's entirely possible that one DB
thinks its locale is, say, "en_US.UTF-8" while the other has "en_US.utf8".
Rather than failing, we should try to allow this where it's clearly OK.
There is already pretty robust encoding lookup in encnames.c, so make
use of that to compare the encoding parts of the names. The locale
identifier parts are just compared case-insensitively, which we were
already doing. The major problem known to exist in the field is variant
encoding-name spellings, so hopefully this will be Good Enough. If not,
we can try being even laxer.
Pavel Raiskup, reviewed by Rushabh Lathia
2014-01-31 01:07:06 +01:00
|
|
|
*/
|
Change the way encoding and locale checks are done in pg_upgrade.
Lc_collate and lc_ctype have been per-database settings since server version
8.4, but pg_upgrade was still treating them as cluster-wide options. It
fetched the values for the template0 databases in old and new cluster, and
compared them. That's backwards; the encoding and locale of the template0
database doesn't matter, as template0 is guaranteed to contain only ASCII
characters. But if there are any other databases that exist on both clusters
(in particular template1 and postgres databases), their encodings and
locales must be compatible.
Also, make the locale comparison more lenient. If the locale names are not
equal, try to canonicalize both of them by passing them to setlocale(). We
used to do that only when upgrading from 9.1 or below, but it seems like a
good idea even with newer versions. If we change the canonical form of a
locale, this allows pg_upgrade to still work. I'm about to do just that to
fix bug #11431, by mapping a locale name that contains non-ASCII characters
to a pure-ASCII alias of the same locale.
No backpatching, because earlier versions of pg_upgrade still support
upgrading from 8.3 servers. That would be more complicated, so it doesn't
seem worth it, given that we haven't received any complaints about this
from users.
2014-10-10 08:59:44 +02:00
|
|
|
canona = get_canonical_locale_name(category, loca);
|
|
|
|
chara = strrchr(canona, '.');
|
|
|
|
lena = chara ? (chara - canona) : strlen(canona);
|
Be forgiving of variant spellings of locale names in pg_upgrade.
Even though the server tries to canonicalize stored locale names, the
platform often doesn't cooperate, so it's entirely possible that one DB
thinks its locale is, say, "en_US.UTF-8" while the other has "en_US.utf8".
Rather than failing, we should try to allow this where it's clearly OK.
There is already pretty robust encoding lookup in encnames.c, so make
use of that to compare the encoding parts of the names. The locale
identifier parts are just compared case-insensitively, which we were
already doing. The major problem known to exist in the field is variant
encoding-name spellings, so hopefully this will be Good Enough. If not,
we can try being even laxer.
Pavel Raiskup, reviewed by Rushabh Lathia
2014-01-31 01:07:06 +01:00
|
|
|
|
Change the way encoding and locale checks are done in pg_upgrade.
Lc_collate and lc_ctype have been per-database settings since server version
8.4, but pg_upgrade was still treating them as cluster-wide options. It
fetched the values for the template0 databases in old and new cluster, and
compared them. That's backwards; the encoding and locale of the template0
database doesn't matter, as template0 is guaranteed to contain only ASCII
characters. But if there are any other databases that exist on both clusters
(in particular template1 and postgres databases), their encodings and
locales must be compatible.
Also, make the locale comparison more lenient. If the locale names are not
equal, try to canonicalize both of them by passing them to setlocale(). We
used to do that only when upgrading from 9.1 or below, but it seems like a
good idea even with newer versions. If we change the canonical form of a
locale, this allows pg_upgrade to still work. I'm about to do just that to
fix bug #11431, by mapping a locale name that contains non-ASCII characters
to a pure-ASCII alias of the same locale.
No backpatching, because earlier versions of pg_upgrade still support
upgrading from 8.3 servers. That would be more complicated, so it doesn't
seem worth it, given that we haven't received any complaints about this
from users.
2014-10-10 08:59:44 +02:00
|
|
|
canonb = get_canonical_locale_name(category, locb);
|
|
|
|
charb = strrchr(canonb, '.');
|
|
|
|
lenb = charb ? (charb - canonb) : strlen(canonb);
|
Be forgiving of variant spellings of locale names in pg_upgrade.
Even though the server tries to canonicalize stored locale names, the
platform often doesn't cooperate, so it's entirely possible that one DB
thinks its locale is, say, "en_US.UTF-8" while the other has "en_US.utf8".
Rather than failing, we should try to allow this where it's clearly OK.
There is already pretty robust encoding lookup in encnames.c, so make
use of that to compare the encoding parts of the names. The locale
identifier parts are just compared case-insensitively, which we were
already doing. The major problem known to exist in the field is variant
encoding-name spellings, so hopefully this will be Good Enough. If not,
we can try being even laxer.
Pavel Raiskup, reviewed by Rushabh Lathia
2014-01-31 01:07:06 +01:00
|
|
|
|
Change the way encoding and locale checks are done in pg_upgrade.
Lc_collate and lc_ctype have been per-database settings since server version
8.4, but pg_upgrade was still treating them as cluster-wide options. It
fetched the values for the template0 databases in old and new cluster, and
compared them. That's backwards; the encoding and locale of the template0
database doesn't matter, as template0 is guaranteed to contain only ASCII
characters. But if there are any other databases that exist on both clusters
(in particular template1 and postgres databases), their encodings and
locales must be compatible.
Also, make the locale comparison more lenient. If the locale names are not
equal, try to canonicalize both of them by passing them to setlocale(). We
used to do that only when upgrading from 9.1 or below, but it seems like a
good idea even with newer versions. If we change the canonical form of a
locale, this allows pg_upgrade to still work. I'm about to do just that to
fix bug #11431, by mapping a locale name that contains non-ASCII characters
to a pure-ASCII alias of the same locale.
No backpatching, because earlier versions of pg_upgrade still support
upgrading from 8.3 servers. That would be more complicated, so it doesn't
seem worth it, given that we haven't received any complaints about this
from users.
2014-10-10 08:59:44 +02:00
|
|
|
if (lena == lenb && pg_strncasecmp(canona, canonb, lena) == 0)
|
|
|
|
return true;
|
Be forgiving of variant spellings of locale names in pg_upgrade.
Even though the server tries to canonicalize stored locale names, the
platform often doesn't cooperate, so it's entirely possible that one DB
thinks its locale is, say, "en_US.UTF-8" while the other has "en_US.utf8".
Rather than failing, we should try to allow this where it's clearly OK.
There is already pretty robust encoding lookup in encnames.c, so make
use of that to compare the encoding parts of the names. The locale
identifier parts are just compared case-insensitively, which we were
already doing. The major problem known to exist in the field is variant
encoding-name spellings, so hopefully this will be Good Enough. If not,
we can try being even laxer.
Pavel Raiskup, reviewed by Rushabh Lathia
2014-01-31 01:07:06 +01:00
|
|
|
|
Change the way encoding and locale checks are done in pg_upgrade.
Lc_collate and lc_ctype have been per-database settings since server version
8.4, but pg_upgrade was still treating them as cluster-wide options. It
fetched the values for the template0 databases in old and new cluster, and
compared them. That's backwards; the encoding and locale of the template0
database doesn't matter, as template0 is guaranteed to contain only ASCII
characters. But if there are any other databases that exist on both clusters
(in particular template1 and postgres databases), their encodings and
locales must be compatible.
Also, make the locale comparison more lenient. If the locale names are not
equal, try to canonicalize both of them by passing them to setlocale(). We
used to do that only when upgrading from 9.1 or below, but it seems like a
good idea even with newer versions. If we change the canonical form of a
locale, this allows pg_upgrade to still work. I'm about to do just that to
fix bug #11431, by mapping a locale name that contains non-ASCII characters
to a pure-ASCII alias of the same locale.
No backpatching, because earlier versions of pg_upgrade still support
upgrading from 8.3 servers. That would be more complicated, so it doesn't
seem worth it, given that we haven't received any complaints about this
from users.
2014-10-10 08:59:44 +02:00
|
|
|
return false;
|
2010-05-12 04:19:11 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static void
|
2011-04-20 03:00:29 +02:00
|
|
|
check_new_cluster_is_empty(void)
|
2010-05-12 04:19:11 +02:00
|
|
|
{
|
|
|
|
int dbnum;
|
|
|
|
|
2010-10-19 23:38:16 +02:00
|
|
|
for (dbnum = 0; dbnum < new_cluster.dbarr.ndbs; dbnum++)
|
2010-05-12 04:19:11 +02:00
|
|
|
{
|
|
|
|
int relnum;
|
2010-10-19 23:38:16 +02:00
|
|
|
RelInfoArr *rel_arr = &new_cluster.dbarr.dbs[dbnum].rel_arr;
|
2010-05-12 04:19:11 +02:00
|
|
|
|
|
|
|
for (relnum = 0; relnum < rel_arr->nrels;
|
|
|
|
relnum++)
|
|
|
|
{
|
|
|
|
/* pg_largeobject and its index should be skipped */
|
|
|
|
if (strcmp(rel_arr->rels[relnum].nspname, "pg_catalog") != 0)
|
2013-10-02 03:24:56 +02:00
|
|
|
pg_fatal("New cluster database \"%s\" is not empty\n",
|
2014-05-06 18:12:18 +02:00
|
|
|
new_cluster.dbarr.dbs[dbnum].db_name);
|
2010-05-12 04:19:11 +02:00
|
|
|
}
|
|
|
|
}
|
Change the way encoding and locale checks are done in pg_upgrade.
Lc_collate and lc_ctype have been per-database settings since server version
8.4, but pg_upgrade was still treating them as cluster-wide options. It
fetched the values for the template0 databases in old and new cluster, and
compared them. That's backwards; the encoding and locale of the template0
database doesn't matter, as template0 is guaranteed to contain only ASCII
characters. But if there are any other databases that exist on both clusters
(in particular template1 and postgres databases), their encodings and
locales must be compatible.
Also, make the locale comparison more lenient. If the locale names are not
equal, try to canonicalize both of them by passing them to setlocale(). We
used to do that only when upgrading from 9.1 or below, but it seems like a
good idea even with newer versions. If we change the canonical form of a
locale, this allows pg_upgrade to still work. I'm about to do just that to
fix bug #11431, by mapping a locale name that contains non-ASCII characters
to a pure-ASCII alias of the same locale.
No backpatching, because earlier versions of pg_upgrade still support
upgrading from 8.3 servers. That would be more complicated, so it doesn't
seem worth it, given that we haven't received any complaints about this
from users.
2014-10-10 08:59:44 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Check that every database that already exists in the new cluster is
|
|
|
|
* compatible with the corresponding database in the old one.
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
check_databases_are_compatible(void)
|
|
|
|
{
|
|
|
|
int newdbnum;
|
|
|
|
int olddbnum;
|
|
|
|
DbInfo *newdbinfo;
|
|
|
|
DbInfo *olddbinfo;
|
|
|
|
|
|
|
|
for (newdbnum = 0; newdbnum < new_cluster.dbarr.ndbs; newdbnum++)
|
|
|
|
{
|
|
|
|
newdbinfo = &new_cluster.dbarr.dbs[newdbnum];
|
2010-05-12 04:19:11 +02:00
|
|
|
|
Change the way encoding and locale checks are done in pg_upgrade.
Lc_collate and lc_ctype have been per-database settings since server version
8.4, but pg_upgrade was still treating them as cluster-wide options. It
fetched the values for the template0 databases in old and new cluster, and
compared them. That's backwards; the encoding and locale of the template0
database doesn't matter, as template0 is guaranteed to contain only ASCII
characters. But if there are any other databases that exist on both clusters
(in particular template1 and postgres databases), their encodings and
locales must be compatible.
Also, make the locale comparison more lenient. If the locale names are not
equal, try to canonicalize both of them by passing them to setlocale(). We
used to do that only when upgrading from 9.1 or below, but it seems like a
good idea even with newer versions. If we change the canonical form of a
locale, this allows pg_upgrade to still work. I'm about to do just that to
fix bug #11431, by mapping a locale name that contains non-ASCII characters
to a pure-ASCII alias of the same locale.
No backpatching, because earlier versions of pg_upgrade still support
upgrading from 8.3 servers. That would be more complicated, so it doesn't
seem worth it, given that we haven't received any complaints about this
from users.
2014-10-10 08:59:44 +02:00
|
|
|
/* Find the corresponding database in the old cluster */
|
|
|
|
for (olddbnum = 0; olddbnum < old_cluster.dbarr.ndbs; olddbnum++)
|
|
|
|
{
|
|
|
|
olddbinfo = &old_cluster.dbarr.dbs[olddbnum];
|
|
|
|
if (strcmp(newdbinfo->db_name, olddbinfo->db_name) == 0)
|
|
|
|
{
|
|
|
|
check_locale_and_encoding(olddbinfo, newdbinfo);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2011-04-20 03:00:29 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2012-03-16 23:54:11 +01:00
|
|
|
/*
|
|
|
|
* create_script_for_cluster_analyze()
|
|
|
|
*
|
|
|
|
* This incrementally generates better optimizer statistics
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
create_script_for_cluster_analyze(char **analyze_script_file_name)
|
|
|
|
{
|
|
|
|
FILE *script = NULL;
|
2013-06-29 01:11:51 +02:00
|
|
|
char *user_specification = "";
|
|
|
|
|
2012-03-16 23:54:11 +01:00
|
|
|
prep_status("Creating script to analyze new cluster");
|
|
|
|
|
2013-10-13 06:09:18 +02:00
|
|
|
if (os_info.user_specified)
|
2013-10-23 01:40:26 +02:00
|
|
|
user_specification = psprintf("-U \"%s\" ", os_info.user);
|
2013-10-13 06:09:18 +02:00
|
|
|
|
2014-10-12 00:38:41 +02:00
|
|
|
*analyze_script_file_name = psprintf("%sanalyze_new_cluster.%s",
|
|
|
|
SCRIPT_PREFIX, SCRIPT_EXT);
|
2012-03-16 23:54:11 +01:00
|
|
|
|
|
|
|
if ((script = fopen_priv(*analyze_script_file_name, "w")) == NULL)
|
2013-10-02 03:24:56 +02:00
|
|
|
pg_fatal("Could not open file \"%s\": %s\n",
|
2014-05-06 18:12:18 +02:00
|
|
|
*analyze_script_file_name, getErrorText(errno));
|
2012-03-16 23:54:11 +01:00
|
|
|
|
|
|
|
#ifndef WIN32
|
|
|
|
/* add shebang header */
|
|
|
|
fprintf(script, "#!/bin/sh\n\n");
|
2012-09-04 11:49:22 +02:00
|
|
|
#else
|
|
|
|
/* suppress command echoing */
|
2012-09-04 15:39:49 +02:00
|
|
|
fprintf(script, "@echo off\n");
|
2012-03-16 23:54:11 +01:00
|
|
|
#endif
|
|
|
|
|
|
|
|
fprintf(script, "echo %sThis script will generate minimal optimizer statistics rapidly%s\n",
|
2012-06-10 21:20:04 +02:00
|
|
|
ECHO_QUOTE, ECHO_QUOTE);
|
2012-03-16 23:54:11 +01:00
|
|
|
fprintf(script, "echo %sso your system is usable, and then gather statistics twice more%s\n",
|
2012-06-10 21:20:04 +02:00
|
|
|
ECHO_QUOTE, ECHO_QUOTE);
|
2012-03-16 23:54:11 +01:00
|
|
|
fprintf(script, "echo %swith increasing accuracy. When it is done, your system will%s\n",
|
2012-06-10 21:20:04 +02:00
|
|
|
ECHO_QUOTE, ECHO_QUOTE);
|
2012-03-16 23:54:11 +01:00
|
|
|
fprintf(script, "echo %shave the default level of optimizer statistics.%s\n",
|
2012-06-10 21:20:04 +02:00
|
|
|
ECHO_QUOTE, ECHO_QUOTE);
|
2012-09-04 11:49:22 +02:00
|
|
|
fprintf(script, "echo%s\n\n", ECHO_BLANK);
|
2012-03-16 23:54:11 +01:00
|
|
|
|
|
|
|
fprintf(script, "echo %sIf you have used ALTER TABLE to modify the statistics target for%s\n",
|
2012-06-10 21:20:04 +02:00
|
|
|
ECHO_QUOTE, ECHO_QUOTE);
|
2012-03-16 23:54:11 +01:00
|
|
|
fprintf(script, "echo %sany tables, you might want to remove them and restore them after%s\n",
|
2012-06-10 21:20:04 +02:00
|
|
|
ECHO_QUOTE, ECHO_QUOTE);
|
2012-03-16 23:54:11 +01:00
|
|
|
fprintf(script, "echo %srunning this script because they will delay fast statistics generation.%s\n",
|
2012-06-10 21:20:04 +02:00
|
|
|
ECHO_QUOTE, ECHO_QUOTE);
|
2012-09-04 11:49:22 +02:00
|
|
|
fprintf(script, "echo%s\n\n", ECHO_BLANK);
|
2012-03-16 23:54:11 +01:00
|
|
|
|
|
|
|
fprintf(script, "echo %sIf you would like default statistics as quickly as possible, cancel%s\n",
|
2012-06-10 21:20:04 +02:00
|
|
|
ECHO_QUOTE, ECHO_QUOTE);
|
2012-03-16 23:54:11 +01:00
|
|
|
fprintf(script, "echo %sthis script and run:%s\n",
|
2012-06-10 21:20:04 +02:00
|
|
|
ECHO_QUOTE, ECHO_QUOTE);
|
2013-06-29 01:11:51 +02:00
|
|
|
fprintf(script, "echo %s \"%s/vacuumdb\" %s--all %s%s\n", ECHO_QUOTE,
|
|
|
|
new_cluster.bindir, user_specification,
|
2012-06-10 21:20:04 +02:00
|
|
|
/* Did we copy the free space files? */
|
|
|
|
(GET_MAJOR_VERSION(old_cluster.major_version) >= 804) ?
|
|
|
|
"--analyze-only" : "--analyze", ECHO_QUOTE);
|
2012-09-04 11:49:22 +02:00
|
|
|
fprintf(script, "echo%s\n\n", ECHO_BLANK);
|
2012-03-16 23:54:11 +01:00
|
|
|
|
2014-04-15 05:15:05 +02:00
|
|
|
fprintf(script, "\"%s/vacuumdb\" %s--all --analyze-in-stages\n",
|
2013-06-29 01:11:51 +02:00
|
|
|
new_cluster.bindir, user_specification);
|
2012-06-10 21:20:04 +02:00
|
|
|
/* Did we copy the free space files? */
|
2014-04-15 05:15:05 +02:00
|
|
|
if (GET_MAJOR_VERSION(old_cluster.major_version) < 804)
|
|
|
|
fprintf(script, "\"%s/vacuumdb\" %s--all\n", new_cluster.bindir,
|
|
|
|
user_specification);
|
2012-03-16 23:54:11 +01:00
|
|
|
|
2012-09-04 11:49:22 +02:00
|
|
|
fprintf(script, "echo%s\n\n", ECHO_BLANK);
|
2012-03-16 23:54:11 +01:00
|
|
|
fprintf(script, "echo %sDone%s\n",
|
2012-06-10 21:20:04 +02:00
|
|
|
ECHO_QUOTE, ECHO_QUOTE);
|
2012-03-16 23:54:11 +01:00
|
|
|
|
|
|
|
fclose(script);
|
|
|
|
|
|
|
|
#ifndef WIN32
|
|
|
|
if (chmod(*analyze_script_file_name, S_IRWXU) != 0)
|
2013-10-02 03:24:56 +02:00
|
|
|
pg_fatal("Could not add execute permission to file \"%s\": %s\n",
|
2014-05-06 18:12:18 +02:00
|
|
|
*analyze_script_file_name, getErrorText(errno));
|
2012-03-16 23:54:11 +01:00
|
|
|
#endif
|
|
|
|
|
2013-06-29 01:11:51 +02:00
|
|
|
if (os_info.user_specified)
|
|
|
|
pg_free(user_specification);
|
|
|
|
|
2012-03-16 23:54:11 +01:00
|
|
|
check_ok();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2010-05-12 04:19:11 +02:00
|
|
|
/*
|
|
|
|
* create_script_for_old_cluster_deletion()
|
|
|
|
*
|
|
|
|
* This is particularly useful for tablespace deletion.
|
|
|
|
*/
|
|
|
|
void
|
2011-06-22 23:50:40 +02:00
|
|
|
create_script_for_old_cluster_deletion(char **deletion_script_file_name)
|
2010-05-12 04:19:11 +02:00
|
|
|
{
|
|
|
|
FILE *script = NULL;
|
|
|
|
int tblnum;
|
2013-02-14 16:53:03 +01:00
|
|
|
char old_cluster_pgdata[MAXPGPATH];
|
2010-05-12 04:19:11 +02:00
|
|
|
|
2014-10-12 00:38:41 +02:00
|
|
|
*deletion_script_file_name = psprintf("%sdelete_old_cluster.%s",
|
|
|
|
SCRIPT_PREFIX, SCRIPT_EXT);
|
2010-05-12 04:19:11 +02:00
|
|
|
|
2013-02-14 16:53:03 +01:00
|
|
|
/*
|
2013-05-29 22:58:43 +02:00
|
|
|
* Some users (oddly) create tablespaces inside the cluster data
|
|
|
|
* directory. We can't create a proper old cluster delete script in that
|
|
|
|
* case.
|
2013-02-14 16:53:03 +01:00
|
|
|
*/
|
|
|
|
strlcpy(old_cluster_pgdata, old_cluster.pgdata, MAXPGPATH);
|
|
|
|
canonicalize_path(old_cluster_pgdata);
|
|
|
|
for (tblnum = 0; tblnum < os_info.num_old_tablespaces; tblnum++)
|
|
|
|
{
|
|
|
|
char old_tablespace_dir[MAXPGPATH];
|
2013-05-29 22:58:43 +02:00
|
|
|
|
2013-02-14 16:53:03 +01:00
|
|
|
strlcpy(old_tablespace_dir, os_info.old_tablespaces[tblnum], MAXPGPATH);
|
|
|
|
canonicalize_path(old_tablespace_dir);
|
|
|
|
if (path_is_prefix_of_path(old_cluster_pgdata, old_tablespace_dir))
|
|
|
|
{
|
|
|
|
/* Unlink file in case it is left over from a previous run. */
|
|
|
|
unlink(*deletion_script_file_name);
|
|
|
|
pg_free(*deletion_script_file_name);
|
|
|
|
*deletion_script_file_name = NULL;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
prep_status("Creating script to delete old cluster");
|
|
|
|
|
2012-03-13 00:47:54 +01:00
|
|
|
if ((script = fopen_priv(*deletion_script_file_name, "w")) == NULL)
|
2013-10-02 03:24:56 +02:00
|
|
|
pg_fatal("Could not open file \"%s\": %s\n",
|
2014-05-06 18:12:18 +02:00
|
|
|
*deletion_script_file_name, getErrorText(errno));
|
2010-05-12 04:19:11 +02:00
|
|
|
|
|
|
|
#ifndef WIN32
|
|
|
|
/* add shebang header */
|
|
|
|
fprintf(script, "#!/bin/sh\n\n");
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/* delete old cluster's default tablespace */
|
2012-09-04 00:06:47 +02:00
|
|
|
fprintf(script, RMDIR_CMD " %s\n", fix_path_separator(old_cluster.pgdata));
|
2010-05-12 04:19:11 +02:00
|
|
|
|
|
|
|
/* delete old cluster's alternate tablespaces */
|
2013-01-09 14:57:47 +01:00
|
|
|
for (tblnum = 0; tblnum < os_info.num_old_tablespaces; tblnum++)
|
2010-05-12 04:19:11 +02:00
|
|
|
{
|
|
|
|
/*
|
|
|
|
* Do the old cluster's per-database directories share a directory
|
|
|
|
* with a new version-specific tablespace?
|
|
|
|
*/
|
2010-10-19 23:38:16 +02:00
|
|
|
if (strlen(old_cluster.tablespace_suffix) == 0)
|
2010-05-12 04:19:11 +02:00
|
|
|
{
|
|
|
|
/* delete per-database directories */
|
|
|
|
int dbnum;
|
|
|
|
|
|
|
|
fprintf(script, "\n");
|
2010-10-19 17:52:43 +02:00
|
|
|
/* remove PG_VERSION? */
|
2010-10-19 23:38:16 +02:00
|
|
|
if (GET_MAJOR_VERSION(old_cluster.major_version) <= 804)
|
2014-02-12 22:35:24 +01:00
|
|
|
fprintf(script, RM_CMD " %s%cPG_VERSION\n",
|
2013-05-29 22:58:43 +02:00
|
|
|
fix_path_separator(os_info.old_tablespaces[tblnum]),
|
2012-09-04 00:06:47 +02:00
|
|
|
PATH_SEPARATOR);
|
2010-10-19 17:52:43 +02:00
|
|
|
|
2011-11-01 18:49:03 +01:00
|
|
|
for (dbnum = 0; dbnum < old_cluster.dbarr.ndbs; dbnum++)
|
2014-02-12 22:35:24 +01:00
|
|
|
fprintf(script, RMDIR_CMD " %s%c%d\n",
|
2013-01-09 14:57:47 +01:00
|
|
|
fix_path_separator(os_info.old_tablespaces[tblnum]),
|
2012-09-04 00:06:47 +02:00
|
|
|
PATH_SEPARATOR, old_cluster.dbarr.dbs[dbnum].db_oid);
|
2010-05-12 04:19:11 +02:00
|
|
|
}
|
|
|
|
else
|
2014-02-12 22:35:24 +01:00
|
|
|
{
|
2014-05-06 18:12:18 +02:00
|
|
|
char *suffix_path = pg_strdup(old_cluster.tablespace_suffix);
|
2010-07-06 21:19:02 +02:00
|
|
|
|
2010-05-12 04:19:11 +02:00
|
|
|
/*
|
|
|
|
* Simply delete the tablespace directory, which might be ".old"
|
|
|
|
* or a version-specific subdirectory.
|
|
|
|
*/
|
|
|
|
fprintf(script, RMDIR_CMD " %s%s\n",
|
2013-05-29 22:58:43 +02:00
|
|
|
fix_path_separator(os_info.old_tablespaces[tblnum]),
|
2014-02-12 22:35:24 +01:00
|
|
|
fix_path_separator(suffix_path));
|
|
|
|
pfree(suffix_path);
|
|
|
|
}
|
2010-05-12 04:19:11 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
fclose(script);
|
|
|
|
|
2010-05-13 17:58:15 +02:00
|
|
|
#ifndef WIN32
|
2010-05-12 04:19:11 +02:00
|
|
|
if (chmod(*deletion_script_file_name, S_IRWXU) != 0)
|
2013-10-02 03:24:56 +02:00
|
|
|
pg_fatal("Could not add execute permission to file \"%s\": %s\n",
|
2014-05-06 18:12:18 +02:00
|
|
|
*deletion_script_file_name, getErrorText(errno));
|
2010-05-13 17:58:15 +02:00
|
|
|
#endif
|
2010-05-12 04:19:11 +02:00
|
|
|
|
2010-10-19 23:38:16 +02:00
|
|
|
check_ok();
|
2010-05-12 04:19:11 +02:00
|
|
|
}
|
2010-07-25 05:28:32 +02:00
|
|
|
|
|
|
|
|
2011-05-07 14:55:13 +02:00
|
|
|
/*
|
2014-08-04 17:56:16 +02:00
|
|
|
* check_is_install_user()
|
2011-05-07 14:55:13 +02:00
|
|
|
*
|
2014-08-04 17:56:16 +02:00
|
|
|
* Check we are the install user, and that the new cluster
|
|
|
|
* has no other users.
|
2011-05-07 14:55:13 +02:00
|
|
|
*/
|
|
|
|
static void
|
2014-08-04 17:56:16 +02:00
|
|
|
check_is_install_user(ClusterInfo *cluster)
|
2011-05-07 14:55:13 +02:00
|
|
|
{
|
|
|
|
PGresult *res;
|
|
|
|
PGconn *conn = connectToServer(cluster, "template1");
|
|
|
|
|
2014-08-04 17:56:16 +02:00
|
|
|
prep_status("Checking database user is the install user");
|
2011-05-09 14:55:36 +02:00
|
|
|
|
2011-05-07 14:55:13 +02:00
|
|
|
/* Can't use pg_authid because only superusers can view it. */
|
|
|
|
res = executeQueryOrDie(conn,
|
2012-06-13 18:19:18 +02:00
|
|
|
"SELECT rolsuper, oid "
|
2011-05-07 14:55:13 +02:00
|
|
|
"FROM pg_catalog.pg_roles "
|
|
|
|
"WHERE rolname = current_user");
|
|
|
|
|
2014-08-04 17:56:16 +02:00
|
|
|
/*
|
|
|
|
* We only allow the install user in the new cluster (see comment below)
|
|
|
|
* and we preserve pg_authid.oid, so this must be the install user in
|
|
|
|
* the old cluster too.
|
|
|
|
*/
|
|
|
|
if (PQntuples(res) != 1 ||
|
|
|
|
atooid(PQgetvalue(res, 0, 1)) != BOOTSTRAP_SUPERUSERID)
|
|
|
|
pg_fatal("database user \"%s\" is not the install user\n",
|
2014-05-06 18:12:18 +02:00
|
|
|
os_info.user);
|
2011-05-07 14:55:13 +02:00
|
|
|
|
2012-06-13 18:19:18 +02:00
|
|
|
PQclear(res);
|
|
|
|
|
|
|
|
res = executeQueryOrDie(conn,
|
|
|
|
"SELECT COUNT(*) "
|
|
|
|
"FROM pg_catalog.pg_roles ");
|
|
|
|
|
|
|
|
if (PQntuples(res) != 1)
|
2013-10-02 03:24:56 +02:00
|
|
|
pg_fatal("could not determine the number of users\n");
|
2012-06-13 18:19:18 +02:00
|
|
|
|
2014-08-04 17:56:16 +02:00
|
|
|
/*
|
|
|
|
* We only allow the install user in the new cluster because other defined
|
|
|
|
* users might match users defined in the old cluster and generate an
|
|
|
|
* error during pg_dump restore.
|
|
|
|
*/
|
|
|
|
if (cluster == &new_cluster && atooid(PQgetvalue(res, 0, 0)) != 1)
|
|
|
|
pg_fatal("Only the install user can be defined in the new cluster.\n");
|
2012-06-13 18:19:18 +02:00
|
|
|
|
2011-05-07 14:55:13 +02:00
|
|
|
PQclear(res);
|
|
|
|
|
|
|
|
PQfinish(conn);
|
2011-05-09 14:55:36 +02:00
|
|
|
|
|
|
|
check_ok();
|
2011-05-07 14:55:13 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-06-14 20:53:35 +02:00
|
|
|
/*
|
|
|
|
* check_for_prepared_transactions()
|
|
|
|
*
|
|
|
|
* Make sure there are no prepared transactions because the storage format
|
|
|
|
* might have changed.
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
check_for_prepared_transactions(ClusterInfo *cluster)
|
|
|
|
{
|
|
|
|
PGresult *res;
|
|
|
|
PGconn *conn = connectToServer(cluster, "template1");
|
|
|
|
|
|
|
|
prep_status("Checking for prepared transactions");
|
|
|
|
|
|
|
|
res = executeQueryOrDie(conn,
|
|
|
|
"SELECT * "
|
2011-08-30 23:15:00 +02:00
|
|
|
"FROM pg_catalog.pg_prepared_xacts");
|
2011-06-14 20:53:35 +02:00
|
|
|
|
|
|
|
if (PQntuples(res) != 0)
|
2013-10-02 03:24:56 +02:00
|
|
|
pg_fatal("The %s cluster contains prepared transactions\n",
|
2014-05-06 18:12:18 +02:00
|
|
|
CLUSTER_NAME(cluster));
|
2011-06-14 20:53:35 +02:00
|
|
|
|
|
|
|
PQclear(res);
|
|
|
|
|
|
|
|
PQfinish(conn);
|
|
|
|
|
|
|
|
check_ok();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2010-07-25 05:47:29 +02:00
|
|
|
/*
|
2010-10-20 00:37:04 +02:00
|
|
|
* check_for_isn_and_int8_passing_mismatch()
|
2010-07-25 05:47:29 +02:00
|
|
|
*
|
2011-05-18 23:30:31 +02:00
|
|
|
* contrib/isn relies on data type int8, and in 8.4 int8 can now be passed
|
2010-07-25 05:47:29 +02:00
|
|
|
* by value. The schema dumps the CREATE TYPE PASSEDBYVALUE setting so
|
|
|
|
* it must match for the old and new servers.
|
|
|
|
*/
|
2011-03-07 02:14:01 +01:00
|
|
|
static void
|
2011-01-01 18:06:36 +01:00
|
|
|
check_for_isn_and_int8_passing_mismatch(ClusterInfo *cluster)
|
2010-07-25 05:47:29 +02:00
|
|
|
{
|
|
|
|
int dbnum;
|
|
|
|
FILE *script = NULL;
|
|
|
|
bool found = false;
|
|
|
|
char output_path[MAXPGPATH];
|
|
|
|
|
2011-05-18 23:30:31 +02:00
|
|
|
prep_status("Checking for contrib/isn with bigint-passing mismatch");
|
2010-07-25 05:47:29 +02:00
|
|
|
|
2010-10-19 23:38:16 +02:00
|
|
|
if (old_cluster.controldata.float8_pass_by_value ==
|
|
|
|
new_cluster.controldata.float8_pass_by_value)
|
2010-07-25 05:47:29 +02:00
|
|
|
{
|
|
|
|
/* no mismatch */
|
2010-10-19 23:38:16 +02:00
|
|
|
check_ok();
|
2010-07-25 05:47:29 +02:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2012-03-13 00:47:54 +01:00
|
|
|
snprintf(output_path, sizeof(output_path),
|
|
|
|
"contrib_isn_and_int8_pass_by_value.txt");
|
2010-07-25 05:47:29 +02:00
|
|
|
|
2011-01-01 18:06:36 +01:00
|
|
|
for (dbnum = 0; dbnum < cluster->dbarr.ndbs; dbnum++)
|
2010-07-25 05:47:29 +02:00
|
|
|
{
|
|
|
|
PGresult *res;
|
|
|
|
bool db_used = false;
|
|
|
|
int ntups;
|
|
|
|
int rowno;
|
|
|
|
int i_nspname,
|
|
|
|
i_proname;
|
2011-01-01 18:06:36 +01:00
|
|
|
DbInfo *active_db = &cluster->dbarr.dbs[dbnum];
|
|
|
|
PGconn *conn = connectToServer(cluster, active_db->db_name);
|
2010-07-25 05:47:29 +02:00
|
|
|
|
|
|
|
/* Find any functions coming from contrib/isn */
|
2010-10-19 23:38:16 +02:00
|
|
|
res = executeQueryOrDie(conn,
|
2010-07-25 05:47:29 +02:00
|
|
|
"SELECT n.nspname, p.proname "
|
|
|
|
"FROM pg_catalog.pg_proc p, "
|
|
|
|
" pg_catalog.pg_namespace n "
|
|
|
|
"WHERE p.pronamespace = n.oid AND "
|
|
|
|
" p.probin = '$libdir/isn'");
|
|
|
|
|
|
|
|
ntups = PQntuples(res);
|
|
|
|
i_nspname = PQfnumber(res, "nspname");
|
|
|
|
i_proname = PQfnumber(res, "proname");
|
|
|
|
for (rowno = 0; rowno < ntups; rowno++)
|
|
|
|
{
|
|
|
|
found = true;
|
2012-03-13 00:47:54 +01:00
|
|
|
if (script == NULL && (script = fopen_priv(output_path, "w")) == NULL)
|
2013-10-02 03:24:56 +02:00
|
|
|
pg_fatal("Could not open file \"%s\": %s\n",
|
2014-05-06 18:12:18 +02:00
|
|
|
output_path, getErrorText(errno));
|
2010-07-25 05:47:29 +02:00
|
|
|
if (!db_used)
|
|
|
|
{
|
2011-07-12 06:13:51 +02:00
|
|
|
fprintf(script, "Database: %s\n", active_db->db_name);
|
2010-07-25 05:47:29 +02:00
|
|
|
db_used = true;
|
|
|
|
}
|
|
|
|
fprintf(script, " %s.%s\n",
|
|
|
|
PQgetvalue(res, rowno, i_nspname),
|
|
|
|
PQgetvalue(res, rowno, i_proname));
|
|
|
|
}
|
|
|
|
|
|
|
|
PQclear(res);
|
|
|
|
|
|
|
|
PQfinish(conn);
|
|
|
|
}
|
|
|
|
|
2011-03-09 03:35:42 +01:00
|
|
|
if (script)
|
2011-04-10 17:42:00 +02:00
|
|
|
fclose(script);
|
2011-03-09 03:35:42 +01:00
|
|
|
|
2010-07-25 05:47:29 +02:00
|
|
|
if (found)
|
|
|
|
{
|
2010-10-19 23:38:16 +02:00
|
|
|
pg_log(PG_REPORT, "fatal\n");
|
2013-10-02 03:24:56 +02:00
|
|
|
pg_fatal("Your installation contains \"contrib/isn\" functions which rely on the\n"
|
2012-06-10 21:20:04 +02:00
|
|
|
"bigint data type. Your old and new clusters pass bigint values\n"
|
|
|
|
"differently so this cluster cannot currently be upgraded. You can\n"
|
2014-05-06 18:12:18 +02:00
|
|
|
"manually upgrade databases that use \"contrib/isn\" facilities and remove\n"
|
|
|
|
"\"contrib/isn\" from the old cluster and restart the upgrade. A list of\n"
|
|
|
|
"the problem functions is in the file:\n"
|
|
|
|
" %s\n\n", output_path);
|
2010-07-25 05:47:29 +02:00
|
|
|
}
|
|
|
|
else
|
2010-10-19 23:38:16 +02:00
|
|
|
check_ok();
|
2010-07-25 05:47:29 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2010-07-25 05:28:32 +02:00
|
|
|
/*
|
|
|
|
* check_for_reg_data_type_usage()
|
|
|
|
* pg_upgrade only preserves these system values:
|
2011-12-05 22:45:19 +01:00
|
|
|
* pg_class.oid
|
2010-07-25 05:28:32 +02:00
|
|
|
* pg_type.oid
|
|
|
|
* pg_enum.oid
|
|
|
|
*
|
2011-12-05 22:45:19 +01:00
|
|
|
* Many of the reg* data types reference system catalog info that is
|
2010-07-25 05:28:32 +02:00
|
|
|
* not preserved, and hence these data types cannot be used in user
|
|
|
|
* tables upgraded by pg_upgrade.
|
|
|
|
*/
|
2011-03-07 02:14:01 +01:00
|
|
|
static void
|
2011-01-01 18:06:36 +01:00
|
|
|
check_for_reg_data_type_usage(ClusterInfo *cluster)
|
2010-07-25 05:28:32 +02:00
|
|
|
{
|
|
|
|
int dbnum;
|
|
|
|
FILE *script = NULL;
|
|
|
|
bool found = false;
|
|
|
|
char output_path[MAXPGPATH];
|
|
|
|
|
2011-07-12 06:13:51 +02:00
|
|
|
prep_status("Checking for reg* system OID user data types");
|
2010-07-25 05:28:32 +02:00
|
|
|
|
2012-03-13 00:47:54 +01:00
|
|
|
snprintf(output_path, sizeof(output_path), "tables_using_reg.txt");
|
2010-07-25 05:28:32 +02:00
|
|
|
|
2011-01-01 18:06:36 +01:00
|
|
|
for (dbnum = 0; dbnum < cluster->dbarr.ndbs; dbnum++)
|
2010-07-25 05:28:32 +02:00
|
|
|
{
|
|
|
|
PGresult *res;
|
|
|
|
bool db_used = false;
|
|
|
|
int ntups;
|
|
|
|
int rowno;
|
|
|
|
int i_nspname,
|
|
|
|
i_relname,
|
|
|
|
i_attname;
|
2011-01-01 18:06:36 +01:00
|
|
|
DbInfo *active_db = &cluster->dbarr.dbs[dbnum];
|
|
|
|
PGconn *conn = connectToServer(cluster, active_db->db_name);
|
2010-07-25 05:28:32 +02:00
|
|
|
|
2012-01-19 22:04:34 +01:00
|
|
|
/*
|
2012-06-10 21:20:04 +02:00
|
|
|
* While several relkinds don't store any data, e.g. views, they can
|
|
|
|
* be used to define data types of other columns, so we check all
|
|
|
|
* relkinds.
|
2012-01-19 22:04:34 +01:00
|
|
|
*/
|
2010-10-19 23:38:16 +02:00
|
|
|
res = executeQueryOrDie(conn,
|
2010-07-25 05:28:32 +02:00
|
|
|
"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 IN ( "
|
2010-10-20 00:37:04 +02:00
|
|
|
" 'pg_catalog.regproc'::pg_catalog.regtype, "
|
2012-06-10 21:20:04 +02:00
|
|
|
" 'pg_catalog.regprocedure'::pg_catalog.regtype, "
|
2010-10-20 00:37:04 +02:00
|
|
|
" 'pg_catalog.regoper'::pg_catalog.regtype, "
|
2012-06-10 21:20:04 +02:00
|
|
|
" 'pg_catalog.regoperator'::pg_catalog.regtype, "
|
2011-12-05 22:45:19 +01:00
|
|
|
/* regclass.oid is preserved, so 'regclass' is OK */
|
2010-10-20 00:37:04 +02:00
|
|
|
/* regtype.oid is preserved, so 'regtype' is OK */
|
2012-06-10 21:20:04 +02:00
|
|
|
" 'pg_catalog.regconfig'::pg_catalog.regtype, "
|
|
|
|
" 'pg_catalog.regdictionary'::pg_catalog.regtype) AND "
|
|
|
|
" c.relnamespace = n.oid AND "
|
2014-05-14 22:26:06 +02:00
|
|
|
" n.nspname NOT IN ('pg_catalog', 'information_schema')");
|
2010-07-25 05:28:32 +02:00
|
|
|
|
|
|
|
ntups = PQntuples(res);
|
|
|
|
i_nspname = PQfnumber(res, "nspname");
|
|
|
|
i_relname = PQfnumber(res, "relname");
|
|
|
|
i_attname = PQfnumber(res, "attname");
|
|
|
|
for (rowno = 0; rowno < ntups; rowno++)
|
|
|
|
{
|
|
|
|
found = true;
|
2012-03-13 00:47:54 +01:00
|
|
|
if (script == NULL && (script = fopen_priv(output_path, "w")) == NULL)
|
2013-10-02 03:24:56 +02:00
|
|
|
pg_fatal("Could not open file \"%s\": %s\n",
|
2014-05-06 18:12:18 +02:00
|
|
|
output_path, getErrorText(errno));
|
2010-07-25 05:28:32 +02:00
|
|
|
if (!db_used)
|
|
|
|
{
|
2011-07-12 06:13:51 +02:00
|
|
|
fprintf(script, "Database: %s\n", active_db->db_name);
|
2010-07-25 05:28:32 +02:00
|
|
|
db_used = true;
|
|
|
|
}
|
|
|
|
fprintf(script, " %s.%s.%s\n",
|
|
|
|
PQgetvalue(res, rowno, i_nspname),
|
|
|
|
PQgetvalue(res, rowno, i_relname),
|
|
|
|
PQgetvalue(res, rowno, i_attname));
|
|
|
|
}
|
|
|
|
|
|
|
|
PQclear(res);
|
|
|
|
|
|
|
|
PQfinish(conn);
|
|
|
|
}
|
|
|
|
|
2011-03-09 03:35:42 +01:00
|
|
|
if (script)
|
|
|
|
fclose(script);
|
|
|
|
|
2010-07-25 05:28:32 +02:00
|
|
|
if (found)
|
|
|
|
{
|
2010-10-19 23:38:16 +02:00
|
|
|
pg_log(PG_REPORT, "fatal\n");
|
2013-10-02 03:24:56 +02:00
|
|
|
pg_fatal("Your installation contains one of the reg* data types in user tables.\n"
|
2012-06-10 21:20:04 +02:00
|
|
|
"These data types reference system OIDs that are not preserved by\n"
|
|
|
|
"pg_upgrade, so this cluster cannot currently be upgraded. You can\n"
|
2014-05-06 18:12:18 +02:00
|
|
|
"remove the problem tables and restart the upgrade. A list of the problem\n"
|
|
|
|
"columns is in the file:\n"
|
|
|
|
" %s\n\n", output_path);
|
2010-07-25 05:28:32 +02:00
|
|
|
}
|
|
|
|
else
|
2010-10-19 23:38:16 +02:00
|
|
|
check_ok();
|
2010-07-25 05:28:32 +02:00
|
|
|
}
|
2011-06-22 23:47:23 +02:00
|
|
|
|
|
|
|
|
2014-09-30 02:19:59 +02:00
|
|
|
/*
|
|
|
|
* check_for_jsonb_9_4_usage()
|
|
|
|
*
|
|
|
|
* JSONB changed its storage format during 9.4 beta, so check for it.
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
check_for_jsonb_9_4_usage(ClusterInfo *cluster)
|
|
|
|
{
|
|
|
|
int dbnum;
|
|
|
|
FILE *script = NULL;
|
|
|
|
bool found = false;
|
|
|
|
char output_path[MAXPGPATH];
|
|
|
|
|
|
|
|
prep_status("Checking for JSONB user data types");
|
|
|
|
|
|
|
|
snprintf(output_path, sizeof(output_path), "tables_using_jsonb.txt");
|
|
|
|
|
|
|
|
for (dbnum = 0; dbnum < cluster->dbarr.ndbs; dbnum++)
|
|
|
|
{
|
|
|
|
PGresult *res;
|
|
|
|
bool db_used = false;
|
|
|
|
int ntups;
|
|
|
|
int rowno;
|
|
|
|
int i_nspname,
|
|
|
|
i_relname,
|
|
|
|
i_attname;
|
|
|
|
DbInfo *active_db = &cluster->dbarr.dbs[dbnum];
|
|
|
|
PGconn *conn = connectToServer(cluster, active_db->db_name);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* While several relkinds don't store any data, e.g. views, they can
|
|
|
|
* be used to define data types of other columns, so we check all
|
|
|
|
* relkinds.
|
|
|
|
*/
|
|
|
|
res = executeQueryOrDie(conn,
|
|
|
|
"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.jsonb'::pg_catalog.regtype AND "
|
|
|
|
" c.relnamespace = n.oid AND "
|
|
|
|
/* exclude possible orphaned temp tables */
|
|
|
|
" n.nspname !~ '^pg_temp_' AND "
|
|
|
|
" n.nspname NOT IN ('pg_catalog', 'information_schema')");
|
|
|
|
|
|
|
|
ntups = PQntuples(res);
|
|
|
|
i_nspname = PQfnumber(res, "nspname");
|
|
|
|
i_relname = PQfnumber(res, "relname");
|
|
|
|
i_attname = PQfnumber(res, "attname");
|
|
|
|
for (rowno = 0; rowno < ntups; rowno++)
|
|
|
|
{
|
|
|
|
found = true;
|
|
|
|
if (script == NULL && (script = fopen_priv(output_path, "w")) == NULL)
|
|
|
|
pg_fatal("Could not open file \"%s\": %s\n",
|
|
|
|
output_path, getErrorText(errno));
|
|
|
|
if (!db_used)
|
|
|
|
{
|
|
|
|
fprintf(script, "Database: %s\n", active_db->db_name);
|
|
|
|
db_used = true;
|
|
|
|
}
|
|
|
|
fprintf(script, " %s.%s.%s\n",
|
|
|
|
PQgetvalue(res, rowno, i_nspname),
|
|
|
|
PQgetvalue(res, rowno, i_relname),
|
|
|
|
PQgetvalue(res, rowno, i_attname));
|
|
|
|
}
|
|
|
|
|
|
|
|
PQclear(res);
|
|
|
|
|
|
|
|
PQfinish(conn);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (script)
|
|
|
|
fclose(script);
|
|
|
|
|
|
|
|
if (found)
|
|
|
|
{
|
|
|
|
pg_log(PG_REPORT, "fatal\n");
|
|
|
|
pg_fatal("Your installation contains one of the JSONB data types in user tables.\n"
|
|
|
|
"The internal format of JSONB changed during 9.4 beta so this cluster cannot currently\n"
|
|
|
|
"be upgraded. You can remove the problem tables and restart the upgrade. A list\n"
|
|
|
|
"of the problem columns is in the file:\n"
|
|
|
|
" %s\n\n", output_path);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
check_ok();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-06-23 02:48:34 +02:00
|
|
|
static void
|
|
|
|
get_bin_version(ClusterInfo *cluster)
|
|
|
|
{
|
2012-06-10 21:20:04 +02:00
|
|
|
char cmd[MAXPGPATH],
|
|
|
|
cmd_output[MAX_STRING];
|
2011-06-23 02:48:34 +02:00
|
|
|
FILE *output;
|
2012-06-10 21:20:04 +02:00
|
|
|
int pre_dot,
|
|
|
|
post_dot;
|
2011-06-23 02:48:34 +02:00
|
|
|
|
Replace SYSTEMQUOTEs with Windows-specific wrapper functions.
It's easy to forget using SYSTEMQUOTEs when constructing command strings
for system() or popen(). Even if we fix all the places missing it now, it is
bound to be forgotten again in the future. Introduce wrapper functions that
do the the extra quoting for you, and get rid of SYSTEMQUOTEs in all the
callers.
We previosly used SYSTEMQUOTEs in all the hard-coded command strings, and
this doesn't change the behavior of those. But user-supplied commands, like
archive_command, restore_command, COPY TO/FROM PROGRAM calls, as well as
pgbench's \shell, will now gain an extra pair of quotes. That is desirable,
but if you have existing scripts or config files that include an extra
pair of quotes, those might need to be adjusted.
Reviewed by Amit Kapila and Tom Lane
2014-05-05 15:07:40 +02:00
|
|
|
snprintf(cmd, sizeof(cmd), "\"%s/pg_ctl\" --version", cluster->bindir);
|
2011-06-23 02:48:34 +02:00
|
|
|
|
2011-10-07 01:37:29 +02:00
|
|
|
if ((output = popen(cmd, "r")) == NULL ||
|
|
|
|
fgets(cmd_output, sizeof(cmd_output), output) == NULL)
|
2013-10-02 03:24:56 +02:00
|
|
|
pg_fatal("Could not get pg_ctl version data using %s: %s\n",
|
2014-05-06 18:12:18 +02:00
|
|
|
cmd, getErrorText(errno));
|
2011-06-23 02:48:34 +02:00
|
|
|
|
|
|
|
pclose(output);
|
|
|
|
|
|
|
|
/* Remove trailing newline */
|
|
|
|
if (strchr(cmd_output, '\n') != NULL)
|
|
|
|
*strchr(cmd_output, '\n') = '\0';
|
|
|
|
|
|
|
|
if (sscanf(cmd_output, "%*s %*s %d.%d", &pre_dot, &post_dot) != 2)
|
2013-10-02 03:24:56 +02:00
|
|
|
pg_fatal("could not get version from %s\n", cmd);
|
2011-06-23 02:48:34 +02:00
|
|
|
|
|
|
|
cluster->bin_version = (pre_dot * 100 + post_dot) * 100;
|
|
|
|
}
|
2012-10-02 17:42:34 +02:00
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* get_canonical_locale_name
|
|
|
|
*
|
|
|
|
* Send the locale name to the system, and hope we get back a canonical
|
|
|
|
* version. This should match the backend's check_locale() function.
|
|
|
|
*/
|
|
|
|
static char *
|
|
|
|
get_canonical_locale_name(int category, const char *locale)
|
|
|
|
{
|
|
|
|
char *save;
|
|
|
|
char *res;
|
|
|
|
|
2014-01-31 00:10:01 +01:00
|
|
|
/* get the current setting, so we can restore it. */
|
2012-10-02 17:42:34 +02:00
|
|
|
save = setlocale(category, NULL);
|
|
|
|
if (!save)
|
2013-10-02 03:24:56 +02:00
|
|
|
pg_fatal("failed to get the current locale\n");
|
2012-10-02 17:42:34 +02:00
|
|
|
|
|
|
|
/* 'save' may be pointing at a modifiable scratch variable, so copy it. */
|
|
|
|
save = pg_strdup(save);
|
|
|
|
|
|
|
|
/* set the locale with setlocale, to see if it accepts it. */
|
|
|
|
res = setlocale(category, locale);
|
|
|
|
|
|
|
|
if (!res)
|
2014-01-31 00:10:01 +01:00
|
|
|
pg_fatal("failed to get system locale name for \"%s\"\n", locale);
|
2012-10-02 17:42:34 +02:00
|
|
|
|
|
|
|
res = pg_strdup(res);
|
|
|
|
|
|
|
|
/* restore old value. */
|
|
|
|
if (!setlocale(category, save))
|
2013-10-02 03:24:56 +02:00
|
|
|
pg_fatal("failed to restore old locale \"%s\"\n", save);
|
2012-10-02 17:42:34 +02:00
|
|
|
|
2012-11-25 04:12:39 +01:00
|
|
|
pg_free(save);
|
2012-10-02 17:42:34 +02:00
|
|
|
|
|
|
|
return res;
|
|
|
|
}
|