than packing everything into 'ctx' and passing that to every function.
#include "pg_upgrade.h"
-static void set_locale_and_encoding(migratorContext *ctx, Cluster whichCluster);
-static void check_new_db_is_empty(migratorContext *ctx);
-static void check_locale_and_encoding(migratorContext *ctx, ControlData *oldctrl,
+static void set_locale_and_encoding(Cluster whichCluster);
+static void check_new_db_is_empty(void);
+static void check_locale_and_encoding(ControlData *oldctrl,
ControlData *newctrl);
-static void check_for_isn_and_int8_passing_mismatch(migratorContext *ctx,
+static void check_for_isn_and_int8_passing_mismatch(
Cluster whichCluster);
-static void check_for_reg_data_type_usage(migratorContext *ctx, Cluster whichCluster);
+static void check_for_reg_data_type_usage(Cluster whichCluster);
void
-output_check_banner(migratorContext *ctx, bool *live_check)
+output_check_banner(bool *live_check)
{
- if (ctx->check && is_server_running(ctx, ctx->old.pgdata))
+ if (user_opts.check && is_server_running(old_cluster.pgdata))
{
*live_check = true;
- if (ctx->old.port == ctx->new.port)
- pg_log(ctx, PG_FATAL, "When checking a live server, "
+ if (old_cluster.port == new_cluster.port)
+ pg_log(PG_FATAL, "When checking a live server, "
"the old and new port numbers must be different.\n");
- pg_log(ctx, PG_REPORT, "PerForming Consistency Checks on Old Live Server\n");
- pg_log(ctx, PG_REPORT, "------------------------------------------------\n");
+ pg_log(PG_REPORT, "PerForming Consistency Checks on Old Live Server\n");
+ pg_log(PG_REPORT, "------------------------------------------------\n");
}
else
{
- pg_log(ctx, PG_REPORT, "Performing Consistency Checks\n");
- pg_log(ctx, PG_REPORT, "-----------------------------\n");
+ pg_log(PG_REPORT, "Performing Consistency Checks\n");
+ pg_log(PG_REPORT, "-----------------------------\n");
}
}
void
-check_old_cluster(migratorContext *ctx, bool live_check,
+check_old_cluster(bool live_check,
char **sequence_script_file_name)
{
/* -- OLD -- */
if (!live_check)
- start_postmaster(ctx, CLUSTER_OLD, false);
+ start_postmaster(CLUSTER_OLD, false);
- set_locale_and_encoding(ctx, CLUSTER_OLD);
+ set_locale_and_encoding(CLUSTER_OLD);
- get_pg_database_relfilenode(ctx, CLUSTER_OLD);
+ get_pg_database_relfilenode(CLUSTER_OLD);
/* Extract a list of databases and tables from the old cluster */
- get_db_and_rel_infos(ctx, &ctx->old.dbarr, CLUSTER_OLD);
+ get_db_and_rel_infos(&old_cluster.dbarr, CLUSTER_OLD);
- init_tablespaces(ctx);
+ init_tablespaces();
- get_loadable_libraries(ctx);
+ get_loadable_libraries();
/*
* Check for various failure cases
*/
- check_for_reg_data_type_usage(ctx, CLUSTER_OLD);
- check_for_isn_and_int8_passing_mismatch(ctx, CLUSTER_OLD);
+ check_for_reg_data_type_usage(CLUSTER_OLD);
+ check_for_isn_and_int8_passing_mismatch(CLUSTER_OLD);
/* old = PG 8.3 checks? */
- if (GET_MAJOR_VERSION(ctx->old.major_version) <= 803)
+ if (GET_MAJOR_VERSION(old_cluster.major_version) <= 803)
{
- old_8_3_check_for_name_data_type_usage(ctx, CLUSTER_OLD);
- old_8_3_check_for_tsquery_usage(ctx, CLUSTER_OLD);
- if (ctx->check)
+ old_8_3_check_for_name_data_type_usage(CLUSTER_OLD);
+ old_8_3_check_for_tsquery_usage(CLUSTER_OLD);
+ if (user_opts.check)
{
- old_8_3_rebuild_tsvector_tables(ctx, true, CLUSTER_OLD);
- old_8_3_invalidate_hash_gin_indexes(ctx, true, CLUSTER_OLD);
- old_8_3_invalidate_bpchar_pattern_ops_indexes(ctx, true, CLUSTER_OLD);
+ old_8_3_rebuild_tsvector_tables(true, CLUSTER_OLD);
+ old_8_3_invalidate_hash_gin_indexes(true, CLUSTER_OLD);
+ old_8_3_invalidate_bpchar_pattern_ops_indexes(true, CLUSTER_OLD);
}
else
* end.
*/
*sequence_script_file_name =
- old_8_3_create_sequence_script(ctx, CLUSTER_OLD);
+ old_8_3_create_sequence_script(CLUSTER_OLD);
}
/* Pre-PG 9.0 had no large object permissions */
- if (GET_MAJOR_VERSION(ctx->old.major_version) <= 804)
- new_9_0_populate_pg_largeobject_metadata(ctx, true, CLUSTER_OLD);
+ if (GET_MAJOR_VERSION(old_cluster.major_version) <= 804)
+ new_9_0_populate_pg_largeobject_metadata(true, CLUSTER_OLD);
/*
* While not a check option, we do this now because this is the only time
* the old server is running.
*/
- if (!ctx->check)
+ if (!user_opts.check)
{
- generate_old_dump(ctx);
- split_old_dump(ctx);
+ generate_old_dump();
+ split_old_dump();
}
if (!live_check)
- stop_postmaster(ctx, false, false);
+ stop_postmaster(false, false);
}
void
-check_new_cluster(migratorContext *ctx)
+check_new_cluster(void)
{
- set_locale_and_encoding(ctx, CLUSTER_NEW);
+ set_locale_and_encoding(CLUSTER_NEW);
- check_new_db_is_empty(ctx);
+ check_new_db_is_empty();
- check_loadable_libraries(ctx);
+ check_loadable_libraries();
- check_locale_and_encoding(ctx, &ctx->old.controldata, &ctx->new.controldata);
+ check_locale_and_encoding(&old_cluster.controldata, &new_cluster.controldata);
- if (ctx->transfer_mode == TRANSFER_MODE_LINK)
- check_hard_link(ctx);
+ if (user_opts.transfer_mode == TRANSFER_MODE_LINK)
+ check_hard_link();
}
void
-report_clusters_compatible(migratorContext *ctx)
+report_clusters_compatible(void)
{
- if (ctx->check)
+ if (user_opts.check)
{
- pg_log(ctx, PG_REPORT, "\n*Clusters are compatible*\n");
+ pg_log(PG_REPORT, "\n*Clusters are compatible*\n");
/* stops new cluster */
- stop_postmaster(ctx, false, false);
- exit_nicely(ctx, false);
+ stop_postmaster(false, false);
+ exit_nicely(false);
}
- pg_log(ctx, PG_REPORT, "\n"
+ pg_log(PG_REPORT, "\n"
"| If pg_upgrade fails after this point, you must\n"
"| re-initdb the new cluster before continuing.\n"
"| You will also need to remove the \".old\" suffix\n"
- "| from %s/global/pg_control.old.\n", ctx->old.pgdata);
+ "| from %s/global/pg_control.old.\n", old_cluster.pgdata);
}
void
-issue_warnings(migratorContext *ctx, char *sequence_script_file_name)
+issue_warnings(char *sequence_script_file_name)
{
/* old = PG 8.3 warnings? */
- if (GET_MAJOR_VERSION(ctx->old.major_version) <= 803)
+ if (GET_MAJOR_VERSION(old_cluster.major_version) <= 803)
{
- start_postmaster(ctx, CLUSTER_NEW, true);
+ start_postmaster(CLUSTER_NEW, true);
/* restore proper sequence values using file created from old server */
if (sequence_script_file_name)
{
- prep_status(ctx, "Adjusting sequences");
- exec_prog(ctx, true,
+ prep_status("Adjusting sequences");
+ exec_prog(true,
SYSTEMQUOTE "\"%s/psql\" --set ON_ERROR_STOP=on "
"--no-psqlrc --port %d --username \"%s\" "
"-f \"%s\" --dbname template1 >> \"%s\"" SYSTEMQUOTE,
- ctx->new.bindir, ctx->new.port, ctx->user,
- sequence_script_file_name, ctx->logfile);
+ new_cluster.bindir, new_cluster.port, os_info.user,
+ sequence_script_file_name, log.filename);
unlink(sequence_script_file_name);
- check_ok(ctx);
+ check_ok();
}
- old_8_3_rebuild_tsvector_tables(ctx, false, CLUSTER_NEW);
- old_8_3_invalidate_hash_gin_indexes(ctx, false, CLUSTER_NEW);
- old_8_3_invalidate_bpchar_pattern_ops_indexes(ctx, false, CLUSTER_NEW);
- stop_postmaster(ctx, false, true);
+ old_8_3_rebuild_tsvector_tables(false, CLUSTER_NEW);
+ old_8_3_invalidate_hash_gin_indexes(false, CLUSTER_NEW);
+ old_8_3_invalidate_bpchar_pattern_ops_indexes(false, CLUSTER_NEW);
+ stop_postmaster(false, true);
}
/* Create dummy large object permissions for old < PG 9.0? */
- if (GET_MAJOR_VERSION(ctx->old.major_version) <= 804)
+ if (GET_MAJOR_VERSION(old_cluster.major_version) <= 804)
{
- start_postmaster(ctx, CLUSTER_NEW, true);
- new_9_0_populate_pg_largeobject_metadata(ctx, false, CLUSTER_NEW);
- stop_postmaster(ctx, false, true);
+ start_postmaster(CLUSTER_NEW, true);
+ new_9_0_populate_pg_largeobject_metadata(false, CLUSTER_NEW);
+ stop_postmaster(false, true);
}
}
void
-output_completion_banner(migratorContext *ctx, char *deletion_script_file_name)
+output_completion_banner(char *deletion_script_file_name)
{
/* Did we migrate the free space files? */
- if (GET_MAJOR_VERSION(ctx->old.major_version) >= 804)
- pg_log(ctx, PG_REPORT,
+ if (GET_MAJOR_VERSION(old_cluster.major_version) >= 804)
+ pg_log(PG_REPORT,
"| Optimizer statistics is not transferred by pg_upgrade\n"
"| so consider running:\n"
"| \tvacuumdb --all --analyze-only\n"
"| on the newly-upgraded cluster.\n\n");
else
- pg_log(ctx, PG_REPORT,
+ pg_log(PG_REPORT,
"| Optimizer statistics and free space information\n"
"| are not transferred by pg_upgrade so consider\n"
"| running:\n"
"| \tvacuumdb --all --analyze\n"
"| on the newly-upgraded cluster.\n\n");
- pg_log(ctx, PG_REPORT,
+ pg_log(PG_REPORT,
"| Running this script will delete the old cluster's data files:\n"
"| \t%s\n",
deletion_script_file_name);
void
-check_cluster_versions(migratorContext *ctx)
+check_cluster_versions(void)
{
/* get old and new cluster versions */
- ctx->old.major_version = get_major_server_version(ctx, &ctx->old.major_version_str, CLUSTER_OLD);
- ctx->new.major_version = get_major_server_version(ctx, &ctx->new.major_version_str, CLUSTER_NEW);
+ old_cluster.major_version = get_major_server_version(&old_cluster.major_version_str, CLUSTER_OLD);
+ new_cluster.major_version = get_major_server_version(&new_cluster.major_version_str, CLUSTER_NEW);
/* We allow migration from/to the same major version for beta upgrades */
- if (GET_MAJOR_VERSION(ctx->old.major_version) < 803)
- pg_log(ctx, PG_FATAL, "This utility can only upgrade from PostgreSQL version 8.3 and later.\n");
+ if (GET_MAJOR_VERSION(old_cluster.major_version) < 803)
+ pg_log(PG_FATAL, "This utility can only upgrade from PostgreSQL version 8.3 and later.\n");
/* Only current PG version is supported as a target */
- if (GET_MAJOR_VERSION(ctx->new.major_version) != GET_MAJOR_VERSION(PG_VERSION_NUM))
- pg_log(ctx, PG_FATAL, "This utility can only upgrade to PostgreSQL version %s.\n",
+ if (GET_MAJOR_VERSION(new_cluster.major_version) != GET_MAJOR_VERSION(PG_VERSION_NUM))
+ pg_log(PG_FATAL, "This utility can only upgrade to PostgreSQL version %s.\n",
PG_MAJORVERSION);
/*
* We can't allow downgrading because we use the target pg_dumpall, and
* pg_dumpall cannot operate on new datbase versions, only older versions.
*/
- if (ctx->old.major_version > ctx->new.major_version)
- pg_log(ctx, PG_FATAL, "This utility cannot be used to downgrade to older major PostgreSQL versions.\n");
+ if (old_cluster.major_version > new_cluster.major_version)
+ pg_log(PG_FATAL, "This utility cannot be used to downgrade to older major PostgreSQL versions.\n");
}
void
-check_cluster_compatibility(migratorContext *ctx, bool live_check)
+check_cluster_compatibility(bool live_check)
{
char libfile[MAXPGPATH];
FILE *lib_test;
* Test pg_upgrade_support.so is in the proper place. We cannot copy it
* ourselves because install directories are typically root-owned.
*/
- snprintf(libfile, sizeof(libfile), "%s/pg_upgrade_support%s", ctx->new.libpath,
+ snprintf(libfile, sizeof(libfile), "%s/pg_upgrade_support%s", new_cluster.libpath,
DLSUFFIX);
if ((lib_test = fopen(libfile, "r")) == NULL)
- pg_log(ctx, PG_FATAL,
+ pg_log(PG_FATAL,
"\npg_upgrade_support%s must be created and installed in %s\n", DLSUFFIX, libfile);
else
fclose(lib_test);
/* get/check pg_control data of servers */
- get_control_data(ctx, &ctx->old, live_check);
- get_control_data(ctx, &ctx->new, false);
- check_control_data(ctx, &ctx->old.controldata, &ctx->new.controldata);
+ get_control_data(&old_cluster, live_check);
+ get_control_data(&new_cluster, false);
+ check_control_data(&old_cluster.controldata, &new_cluster.controldata);
/* Is it 9.0 but without tablespace directories? */
- if (GET_MAJOR_VERSION(ctx->new.major_version) == 900 &&
- ctx->new.controldata.cat_ver < TABLE_SPACE_SUBDIRS)
- pg_log(ctx, PG_FATAL, "This utility can only upgrade to PostgreSQL version 9.0 after 2010-01-11\n"
+ if (GET_MAJOR_VERSION(new_cluster.major_version) == 900 &&
+ new_cluster.controldata.cat_ver < TABLE_SPACE_SUBDIRS)
+ pg_log(PG_FATAL, "This utility can only upgrade to PostgreSQL version 9.0 after 2010-01-11\n"
"because of backend API changes made during development.\n");
}
* query the database to get the template0 locale
*/
static void
-set_locale_and_encoding(migratorContext *ctx, Cluster whichCluster)
+set_locale_and_encoding(Cluster whichCluster)
{
+ ClusterInfo *active_cluster = ACTIVE_CLUSTER(whichCluster);
+ ControlData *ctrl = &active_cluster->controldata;
PGconn *conn;
PGresult *res;
int i_encoding;
- ControlData *ctrl = (whichCluster == CLUSTER_OLD) ?
- &ctx->old.controldata : &ctx->new.controldata;
- int cluster_version = (whichCluster == CLUSTER_OLD) ?
- ctx->old.major_version : ctx->new.major_version;
+ int cluster_version = active_cluster->major_version;
- conn = connectToServer(ctx, "template1", whichCluster);
+ conn = connectToServer("template1", whichCluster);
/* for pg < 80400, we got the values from pg_controldata */
if (cluster_version >= 80400)
int i_datcollate;
int i_datctype;
- res = executeQueryOrDie(ctx, conn,
+ res = executeQueryOrDie(conn,
"SELECT datcollate, datctype "
"FROM pg_catalog.pg_database "
"WHERE datname = 'template0' ");
i_datcollate = PQfnumber(res, "datcollate");
i_datctype = PQfnumber(res, "datctype");
- ctrl->lc_collate = pg_strdup(ctx, PQgetvalue(res, 0, i_datcollate));
- ctrl->lc_ctype = pg_strdup(ctx, PQgetvalue(res, 0, i_datctype));
+ ctrl->lc_collate = pg_strdup(PQgetvalue(res, 0, i_datcollate));
+ ctrl->lc_ctype = pg_strdup(PQgetvalue(res, 0, i_datctype));
PQclear(res);
}
- res = executeQueryOrDie(ctx, conn,
+ res = executeQueryOrDie(conn,
"SELECT pg_catalog.pg_encoding_to_char(encoding) "
"FROM pg_catalog.pg_database "
"WHERE datname = 'template0' ");
assert(PQntuples(res) == 1);
i_encoding = PQfnumber(res, "pg_encoding_to_char");
- ctrl->encoding = pg_strdup(ctx, PQgetvalue(res, 0, i_encoding));
+ ctrl->encoding = pg_strdup(PQgetvalue(res, 0, i_encoding));
PQclear(res);
* we probably had to get via a database query.
*/
static void
-check_locale_and_encoding(migratorContext *ctx, ControlData *oldctrl,
+check_locale_and_encoding(ControlData *oldctrl,
ControlData *newctrl)
{
if (strcmp(oldctrl->lc_collate, newctrl->lc_collate) != 0)
- pg_log(ctx, PG_FATAL,
+ pg_log(PG_FATAL,
"old and new cluster lc_collate values do not match\n");
if (strcmp(oldctrl->lc_ctype, newctrl->lc_ctype) != 0)
- pg_log(ctx, PG_FATAL,
+ pg_log(PG_FATAL,
"old and new cluster lc_ctype values do not match\n");
if (strcmp(oldctrl->encoding, newctrl->encoding) != 0)
- pg_log(ctx, PG_FATAL,
+ pg_log(PG_FATAL,
"old and new cluster encoding values do not match\n");
}
static void
-check_new_db_is_empty(migratorContext *ctx)
+check_new_db_is_empty(void)
{
int dbnum;
bool found = false;
- get_db_and_rel_infos(ctx, &ctx->new.dbarr, CLUSTER_NEW);
+ get_db_and_rel_infos(&new_cluster.dbarr, CLUSTER_NEW);
- for (dbnum = 0; dbnum < ctx->new.dbarr.ndbs; dbnum++)
+ for (dbnum = 0; dbnum < new_cluster.dbarr.ndbs; dbnum++)
{
int relnum;
- RelInfoArr *rel_arr = &ctx->new.dbarr.dbs[dbnum].rel_arr;
+ RelInfoArr *rel_arr = &new_cluster.dbarr.dbs[dbnum].rel_arr;
for (relnum = 0; relnum < rel_arr->nrels;
relnum++)
}
}
- dbarr_free(&ctx->new.dbarr);
+ dbarr_free(&new_cluster.dbarr);
if (found)
- pg_log(ctx, PG_FATAL, "New cluster is not empty; exiting\n");
+ pg_log(PG_FATAL, "New cluster is not empty; exiting\n");
}
* This is particularly useful for tablespace deletion.
*/
void
-create_script_for_old_cluster_deletion(migratorContext *ctx,
+create_script_for_old_cluster_deletion(
char **deletion_script_file_name)
{
FILE *script = NULL;
int tblnum;
- *deletion_script_file_name = pg_malloc(ctx, MAXPGPATH);
+ *deletion_script_file_name = pg_malloc(MAXPGPATH);
- prep_status(ctx, "Creating script to delete old cluster");
+ prep_status("Creating script to delete old cluster");
snprintf(*deletion_script_file_name, MAXPGPATH, "%s/delete_old_cluster.%s",
- ctx->cwd, SCRIPT_EXT);
+ os_info.cwd, SCRIPT_EXT);
if ((script = fopen(*deletion_script_file_name, "w")) == NULL)
- pg_log(ctx, PG_FATAL, "Could not create necessary file: %s\n",
+ pg_log(PG_FATAL, "Could not create necessary file: %s\n",
*deletion_script_file_name);
#ifndef WIN32
#endif
/* delete old cluster's default tablespace */
- fprintf(script, RMDIR_CMD " %s\n", ctx->old.pgdata);
+ fprintf(script, RMDIR_CMD " %s\n", old_cluster.pgdata);
/* delete old cluster's alternate tablespaces */
- for (tblnum = 0; tblnum < ctx->num_tablespaces; tblnum++)
+ for (tblnum = 0; tblnum < os_info.num_tablespaces; tblnum++)
{
/*
* Do the old cluster's per-database directories share a directory
* with a new version-specific tablespace?
*/
- if (strlen(ctx->old.tablespace_suffix) == 0)
+ if (strlen(old_cluster.tablespace_suffix) == 0)
{
/* delete per-database directories */
int dbnum;
fprintf(script, "\n");
/* remove PG_VERSION? */
- if (GET_MAJOR_VERSION(ctx->old.major_version) <= 804)
+ if (GET_MAJOR_VERSION(old_cluster.major_version) <= 804)
fprintf(script, RM_CMD " %s%s/PG_VERSION\n",
- ctx->tablespaces[tblnum], ctx->old.tablespace_suffix);
+ os_info.tablespaces[tblnum], old_cluster.tablespace_suffix);
- for (dbnum = 0; dbnum < ctx->new.dbarr.ndbs; dbnum++)
+ for (dbnum = 0; dbnum < new_cluster.dbarr.ndbs; dbnum++)
{
fprintf(script, RMDIR_CMD " %s%s/%d\n",
- ctx->tablespaces[tblnum], ctx->old.tablespace_suffix,
- ctx->old.dbarr.dbs[dbnum].db_oid);
+ os_info.tablespaces[tblnum], old_cluster.tablespace_suffix,
+ old_cluster.dbarr.dbs[dbnum].db_oid);
}
}
else
* or a version-specific subdirectory.
*/
fprintf(script, RMDIR_CMD " %s%s\n",
- ctx->tablespaces[tblnum], ctx->old.tablespace_suffix);
+ os_info.tablespaces[tblnum], old_cluster.tablespace_suffix);
}
fclose(script);
#ifndef WIN32
if (chmod(*deletion_script_file_name, S_IRWXU) != 0)
- pg_log(ctx, PG_FATAL, "Could not add execute permission to file: %s\n",
+ pg_log(PG_FATAL, "Could not add execute permission to file: %s\n",
*deletion_script_file_name);
#endif
- check_ok(ctx);
+ check_ok();
}
* it must match for the old and new servers.
*/
void
-check_for_isn_and_int8_passing_mismatch(migratorContext *ctx, Cluster whichCluster)
+check_for_isn_and_int8_passing_mismatch(Cluster whichCluster)
{
- ClusterInfo *active_cluster = (whichCluster == CLUSTER_OLD) ?
- &ctx->old : &ctx->new;
+ ClusterInfo *active_cluster = ACTIVE_CLUSTER(whichCluster);
int dbnum;
FILE *script = NULL;
bool found = false;
char output_path[MAXPGPATH];
- prep_status(ctx, "Checking for /contrib/isn with bigint-passing mismatch");
+ prep_status("Checking for /contrib/isn with bigint-passing mismatch");
- if (ctx->old.controldata.float8_pass_by_value ==
- ctx->new.controldata.float8_pass_by_value)
+ if (old_cluster.controldata.float8_pass_by_value ==
+ new_cluster.controldata.float8_pass_by_value)
{
/* no mismatch */
- check_ok(ctx);
+ check_ok();
return;
}
snprintf(output_path, sizeof(output_path), "%s/contrib_isn_and_int8_pass_by_value.txt",
- ctx->cwd);
+ os_info.cwd);
for (dbnum = 0; dbnum < active_cluster->dbarr.ndbs; dbnum++)
{
int i_nspname,
i_proname;
DbInfo *active_db = &active_cluster->dbarr.dbs[dbnum];
- PGconn *conn = connectToServer(ctx, active_db->db_name, whichCluster);
+ PGconn *conn = connectToServer(active_db->db_name, whichCluster);
/* Find any functions coming from contrib/isn */
- res = executeQueryOrDie(ctx, conn,
+ res = executeQueryOrDie(conn,
"SELECT n.nspname, p.proname "
"FROM pg_catalog.pg_proc p, "
" pg_catalog.pg_namespace n "
{
found = true;
if (script == NULL && (script = fopen(output_path, "w")) == NULL)
- pg_log(ctx, PG_FATAL, "Could not create necessary file: %s\n", output_path);
+ pg_log(PG_FATAL, "Could not create necessary file: %s\n", output_path);
if (!db_used)
{
fprintf(script, "Database: %s\n", active_db->db_name);
if (found)
{
fclose(script);
- pg_log(ctx, PG_REPORT, "fatal\n");
- pg_log(ctx, PG_FATAL,
+ pg_log(PG_REPORT, "fatal\n");
+ pg_log(PG_FATAL,
"| Your installation contains \"/contrib/isn\" functions\n"
"| which rely on the bigint data type. Your old and\n"
"| new clusters pass bigint values differently so this\n"
"| \t%s\n\n", output_path);
}
else
- check_ok(ctx);
+ check_ok();
}
* tables upgraded by pg_upgrade.
*/
void
-check_for_reg_data_type_usage(migratorContext *ctx, Cluster whichCluster)
+check_for_reg_data_type_usage(Cluster whichCluster)
{
- ClusterInfo *active_cluster = (whichCluster == CLUSTER_OLD) ?
- &ctx->old : &ctx->new;
+ ClusterInfo *active_cluster = ACTIVE_CLUSTER(whichCluster);
int dbnum;
FILE *script = NULL;
bool found = false;
char output_path[MAXPGPATH];
- prep_status(ctx, "Checking for reg* system oid user data types");
+ prep_status("Checking for reg* system oid user data types");
snprintf(output_path, sizeof(output_path), "%s/tables_using_reg.txt",
- ctx->cwd);
+ os_info.cwd);
for (dbnum = 0; dbnum < active_cluster->dbarr.ndbs; dbnum++)
{
i_relname,
i_attname;
DbInfo *active_db = &active_cluster->dbarr.dbs[dbnum];
- PGconn *conn = connectToServer(ctx, active_db->db_name, whichCluster);
+ PGconn *conn = connectToServer(active_db->db_name, whichCluster);
- res = executeQueryOrDie(ctx, conn,
+ res = executeQueryOrDie(conn,
"SELECT n.nspname, c.relname, a.attname "
"FROM pg_catalog.pg_class c, "
" pg_catalog.pg_namespace n, "
{
found = true;
if (script == NULL && (script = fopen(output_path, "w")) == NULL)
- pg_log(ctx, PG_FATAL, "Could not create necessary file: %s\n", output_path);
+ pg_log(PG_FATAL, "Could not create necessary file: %s\n", output_path);
if (!db_used)
{
fprintf(script, "Database: %s\n", active_db->db_name);
if (found)
{
fclose(script);
- pg_log(ctx, PG_REPORT, "fatal\n");
- pg_log(ctx, PG_FATAL,
+ pg_log(PG_REPORT, "fatal\n");
+ pg_log(PG_FATAL,
"| Your installation contains one of the reg* data types in\n"
"| user tables. These data types reference system oids that\n"
"| are not preserved by pg_upgrade, so this cluster cannot\n"
"| \t%s\n\n", output_path);
}
else
- check_ok(ctx);
+ check_ok();
}
#include <ctype.h>
-static void putenv2(migratorContext *ctx, const char *var, const char *val);
+static void putenv2(const char *var, const char *val);
/*
* get_control_data()
* return valid xid data for a running server.
*/
void
-get_control_data(migratorContext *ctx, ClusterInfo *cluster, bool live_check)
+get_control_data(ClusterInfo *cluster, bool live_check)
{
char cmd[MAXPGPATH];
char bufin[MAX_STRING];
* English. Copied from pg_regress.c.
*/
if (getenv("LC_COLLATE"))
- lc_collate = pg_strdup(ctx, getenv("LC_COLLATE"));
+ lc_collate = pg_strdup(getenv("LC_COLLATE"));
if (getenv("LC_CTYPE"))
- lc_ctype = pg_strdup(ctx, getenv("LC_CTYPE"));
+ lc_ctype = pg_strdup(getenv("LC_CTYPE"));
if (getenv("LC_MONETARY"))
- lc_monetary = pg_strdup(ctx, getenv("LC_MONETARY"));
+ lc_monetary = pg_strdup(getenv("LC_MONETARY"));
if (getenv("LC_NUMERIC"))
- lc_numeric = pg_strdup(ctx, getenv("LC_NUMERIC"));
+ lc_numeric = pg_strdup(getenv("LC_NUMERIC"));
if (getenv("LC_TIME"))
- lc_time = pg_strdup(ctx, getenv("LC_TIME"));
+ lc_time = pg_strdup(getenv("LC_TIME"));
if (getenv("LANG"))
- lang = pg_strdup(ctx, getenv("LANG"));
+ lang = pg_strdup(getenv("LANG"));
if (getenv("LANGUAGE"))
- language = pg_strdup(ctx, getenv("LANGUAGE"));
+ language = pg_strdup(getenv("LANGUAGE"));
if (getenv("LC_ALL"))
- lc_all = pg_strdup(ctx, getenv("LC_ALL"));
+ lc_all = pg_strdup(getenv("LC_ALL"));
if (getenv("LC_MESSAGES"))
- lc_messages = pg_strdup(ctx, getenv("LC_MESSAGES"));
-
- putenv2(ctx, "LC_COLLATE", NULL);
- putenv2(ctx, "LC_CTYPE", NULL);
- putenv2(ctx, "LC_MONETARY", NULL);
- putenv2(ctx, "LC_NUMERIC", NULL);
- putenv2(ctx, "LC_TIME", NULL);
- putenv2(ctx, "LANG",
+ lc_messages = pg_strdup(getenv("LC_MESSAGES"));
+
+ putenv2("LC_COLLATE", NULL);
+ putenv2("LC_CTYPE", NULL);
+ putenv2("LC_MONETARY", NULL);
+ putenv2("LC_NUMERIC", NULL);
+ putenv2("LC_TIME", NULL);
+ putenv2("LANG",
#ifndef WIN32
NULL);
#else
/* On Windows the default locale cannot be English, so force it */
"en");
#endif
- putenv2(ctx, "LANGUAGE", NULL);
- putenv2(ctx, "LC_ALL", NULL);
- putenv2(ctx, "LC_MESSAGES", "C");
+ putenv2("LANGUAGE", NULL);
+ putenv2("LC_ALL", NULL);
+ putenv2("LC_MESSAGES", "C");
snprintf(cmd, sizeof(cmd), SYSTEMQUOTE "\"%s/%s \"%s\"" SYSTEMQUOTE,
cluster->bindir,
fflush(stderr);
if ((output = popen(cmd, "r")) == NULL)
- pg_log(ctx, PG_FATAL, "Could not get control data: %s\n",
+ pg_log(PG_FATAL, "Could not get control data: %s\n",
getErrorText(errno));
/* Only pre-8.4 has these so if they are not set below we will check later */
/* we have the result of cmd in "output". so parse it line by line now */
while (fgets(bufin, sizeof(bufin), output))
{
- if (ctx->debug)
- fputs(bufin, ctx->debug_fd);
+ if (log.debug)
+ fputs(bufin, log.debug_fd);
#ifdef WIN32
{
for (p = bufin; *p; p++)
if (!isascii(*p))
- pg_log(ctx, PG_FATAL,
+ pg_log(PG_FATAL,
"The 8.3 cluster's pg_controldata is incapable of outputting ASCII, even\n"
"with LANG=C. You must upgrade this cluster to a newer version of Postgres\n"
"8.3 to fix this bug. Postgres 8.3.7 and later are known to work properly.\n");
p = strchr(p, ':');
if (p == NULL || strlen(p) <= 1)
- pg_log(ctx, PG_FATAL, "%d: pg_resetxlog problem\n", __LINE__);
+ pg_log(PG_FATAL, "%d: pg_resetxlog problem\n", __LINE__);
p++; /* removing ':' char */
cluster->controldata.ctrl_ver = str2uint(p);
p = strchr(p, ':');
if (p == NULL || strlen(p) <= 1)
- pg_log(ctx, PG_FATAL, "%d: controldata retrieval problem\n", __LINE__);
+ pg_log(PG_FATAL, "%d: controldata retrieval problem\n", __LINE__);
p++; /* removing ':' char */
cluster->controldata.cat_ver = str2uint(p);
p = strchr(p, ':');
if (p == NULL || strlen(p) <= 1)
- pg_log(ctx, PG_FATAL, "%d: controldata retrieval problem\n", __LINE__);
+ pg_log(PG_FATAL, "%d: controldata retrieval problem\n", __LINE__);
p++; /* removing ':' char */
cluster->controldata.logid = str2uint(p);
p = strchr(p, ':');
if (p == NULL || strlen(p) <= 1)
- pg_log(ctx, PG_FATAL, "%d: controldata retrieval problem\n", __LINE__);
+ pg_log(PG_FATAL, "%d: controldata retrieval problem\n", __LINE__);
p++; /* removing ':' char */
cluster->controldata.nxtlogseg = str2uint(p);
p = strchr(p, ':');
if (p == NULL || strlen(p) <= 1)
- pg_log(ctx, PG_FATAL, "%d: controldata retrieval problem\n", __LINE__);
+ pg_log(PG_FATAL, "%d: controldata retrieval problem\n", __LINE__);
p++; /* removing ':' char */
cluster->controldata.chkpnt_tli = str2uint(p);
op = strchr(p, ':');
if (op == NULL || strlen(op) <= 1)
- pg_log(ctx, PG_FATAL, "%d: controldata retrieval problem\n", __LINE__);
+ pg_log(PG_FATAL, "%d: controldata retrieval problem\n", __LINE__);
op++; /* removing ':' char */
cluster->controldata.chkpnt_nxtxid = str2uint(op);
p = strchr(p, ':');
if (p == NULL || strlen(p) <= 1)
- pg_log(ctx, PG_FATAL, "%d: controldata retrieval problem\n", __LINE__);
+ pg_log(PG_FATAL, "%d: controldata retrieval problem\n", __LINE__);
p++; /* removing ':' char */
cluster->controldata.chkpnt_nxtoid = str2uint(p);
p = strchr(p, ':');
if (p == NULL || strlen(p) <= 1)
- pg_log(ctx, PG_FATAL, "%d: controldata retrieval problem\n", __LINE__);
+ pg_log(PG_FATAL, "%d: controldata retrieval problem\n", __LINE__);
p++; /* removing ':' char */
cluster->controldata.align = str2uint(p);
p = strchr(p, ':');
if (p == NULL || strlen(p) <= 1)
- pg_log(ctx, PG_FATAL, "%d: controldata retrieval problem\n", __LINE__);
+ pg_log(PG_FATAL, "%d: controldata retrieval problem\n", __LINE__);
p++; /* removing ':' char */
cluster->controldata.blocksz = str2uint(p);
p = strchr(p, ':');
if (p == NULL || strlen(p) <= 1)
- pg_log(ctx, PG_FATAL, "%d: controldata retrieval problem\n", __LINE__);
+ pg_log(PG_FATAL, "%d: controldata retrieval problem\n", __LINE__);
p++; /* removing ':' char */
cluster->controldata.largesz = str2uint(p);
p = strchr(p, ':');
if (p == NULL || strlen(p) <= 1)
- pg_log(ctx, PG_FATAL, "%d: controldata retrieval problem\n", __LINE__);
+ pg_log(PG_FATAL, "%d: controldata retrieval problem\n", __LINE__);
p++; /* removing ':' char */
cluster->controldata.walsz = str2uint(p);
p = strchr(p, ':');
if (p == NULL || strlen(p) <= 1)
- pg_log(ctx, PG_FATAL, "%d: controldata retrieval problem\n", __LINE__);
+ pg_log(PG_FATAL, "%d: controldata retrieval problem\n", __LINE__);
p++; /* removing ':' char */
cluster->controldata.walseg = str2uint(p);
p = strchr(p, ':');
if (p == NULL || strlen(p) <= 1)
- pg_log(ctx, PG_FATAL, "%d: controldata retrieval problem\n", __LINE__);
+ pg_log(PG_FATAL, "%d: controldata retrieval problem\n", __LINE__);
p++; /* removing ':' char */
cluster->controldata.ident = str2uint(p);
p = strchr(p, ':');
if (p == NULL || strlen(p) <= 1)
- pg_log(ctx, PG_FATAL, "%d: controldata retrieval problem\n", __LINE__);
+ pg_log(PG_FATAL, "%d: controldata retrieval problem\n", __LINE__);
p++; /* removing ':' char */
cluster->controldata.index = str2uint(p);
p = strchr(p, ':');
if (p == NULL || strlen(p) <= 1)
- pg_log(ctx, PG_FATAL, "%d: controldata retrieval problem\n", __LINE__);
+ pg_log(PG_FATAL, "%d: controldata retrieval problem\n", __LINE__);
p++; /* removing ':' char */
cluster->controldata.toast = str2uint(p);
p = strchr(p, ':');
if (p == NULL || strlen(p) <= 1)
- pg_log(ctx, PG_FATAL, "%d: controldata retrieval problem\n", __LINE__);
+ pg_log(PG_FATAL, "%d: controldata retrieval problem\n", __LINE__);
p++; /* removing ':' char */
cluster->controldata.date_is_int = strstr(p, "64-bit integers") != NULL;
p = strchr(p, ':');
if (p == NULL || strlen(p) <= 1)
- pg_log(ctx, PG_FATAL, "%d: controldata retrieval problem\n", __LINE__);
+ pg_log(PG_FATAL, "%d: controldata retrieval problem\n", __LINE__);
p++; /* removing ':' char */
/* used later for /contrib check */
p = strchr(p, ':');
if (p == NULL || strlen(p) <= 1)
- pg_log(ctx, PG_FATAL, "%d: controldata retrieval problem\n", __LINE__);
+ pg_log(PG_FATAL, "%d: controldata retrieval problem\n", __LINE__);
p++; /* removing ':' char */
/* skip leading spaces and remove trailing newline */
p += strspn(p, " ");
if (strlen(p) > 0 && *(p + strlen(p) - 1) == '\n')
*(p + strlen(p) - 1) = '\0';
- cluster->controldata.lc_collate = pg_strdup(ctx, p);
+ cluster->controldata.lc_collate = pg_strdup(p);
}
/* In pre-8.4 only */
else if ((p = strstr(bufin, "LC_CTYPE:")) != NULL)
p = strchr(p, ':');
if (p == NULL || strlen(p) <= 1)
- pg_log(ctx, PG_FATAL, "%d: controldata retrieval problem\n", __LINE__);
+ pg_log(PG_FATAL, "%d: controldata retrieval problem\n", __LINE__);
p++; /* removing ':' char */
/* skip leading spaces and remove trailing newline */
p += strspn(p, " ");
if (strlen(p) > 0 && *(p + strlen(p) - 1) == '\n')
*(p + strlen(p) - 1) = '\0';
- cluster->controldata.lc_ctype = pg_strdup(ctx, p);
+ cluster->controldata.lc_ctype = pg_strdup(p);
}
}
/*
* Restore environment variables
*/
- putenv2(ctx, "LC_COLLATE", lc_collate);
- putenv2(ctx, "LC_CTYPE", lc_ctype);
- putenv2(ctx, "LC_MONETARY", lc_monetary);
- putenv2(ctx, "LC_NUMERIC", lc_numeric);
- putenv2(ctx, "LC_TIME", lc_time);
- putenv2(ctx, "LANG", lang);
- putenv2(ctx, "LANGUAGE", language);
- putenv2(ctx, "LC_ALL", lc_all);
- putenv2(ctx, "LC_MESSAGES", lc_messages);
+ putenv2("LC_COLLATE", lc_collate);
+ putenv2("LC_CTYPE", lc_ctype);
+ putenv2("LC_MONETARY", lc_monetary);
+ putenv2("LC_NUMERIC", lc_numeric);
+ putenv2("LC_TIME", lc_time);
+ putenv2("LANG", lang);
+ putenv2("LANGUAGE", language);
+ putenv2("LC_ALL", lc_all);
+ putenv2("LC_MESSAGES", lc_messages);
pg_free(lc_collate);
pg_free(lc_ctype);
!got_walseg || !got_ident || !got_index || !got_toast ||
!got_date_is_int || !got_float8_pass_by_value)
{
- pg_log(ctx, PG_REPORT,
+ pg_log(PG_REPORT,
"Some required control information is missing; cannot find:\n");
if (!got_xid)
- pg_log(ctx, PG_REPORT, " checkpoint next XID\n");
+ pg_log(PG_REPORT, " checkpoint next XID\n");
if (!got_oid)
- pg_log(ctx, PG_REPORT, " latest checkpoint next OID\n");
+ pg_log(PG_REPORT, " latest checkpoint next OID\n");
if (!live_check && !got_log_id)
- pg_log(ctx, PG_REPORT, " first log file ID after reset\n");
+ pg_log(PG_REPORT, " first log file ID after reset\n");
if (!live_check && !got_log_seg)
- pg_log(ctx, PG_REPORT, " first log file segment after reset\n");
+ pg_log(PG_REPORT, " first log file segment after reset\n");
if (!got_tli)
- pg_log(ctx, PG_REPORT, " latest checkpoint timeline ID\n");
+ pg_log(PG_REPORT, " latest checkpoint timeline ID\n");
if (!got_align)
- pg_log(ctx, PG_REPORT, " maximum alignment\n");
+ pg_log(PG_REPORT, " maximum alignment\n");
if (!got_blocksz)
- pg_log(ctx, PG_REPORT, " block size\n");
+ pg_log(PG_REPORT, " block size\n");
if (!got_largesz)
- pg_log(ctx, PG_REPORT, " large relation segment size\n");
+ pg_log(PG_REPORT, " large relation segment size\n");
if (!got_walsz)
- pg_log(ctx, PG_REPORT, " WAL block size\n");
+ pg_log(PG_REPORT, " WAL block size\n");
if (!got_walseg)
- pg_log(ctx, PG_REPORT, " WAL segment size\n");
+ pg_log(PG_REPORT, " WAL segment size\n");
if (!got_ident)
- pg_log(ctx, PG_REPORT, " maximum identifier length\n");
+ pg_log(PG_REPORT, " maximum identifier length\n");
if (!got_index)
- pg_log(ctx, PG_REPORT, " maximum number of indexed columns\n");
+ pg_log(PG_REPORT, " maximum number of indexed columns\n");
if (!got_toast)
- pg_log(ctx, PG_REPORT, " maximum TOAST chunk size\n");
+ pg_log(PG_REPORT, " maximum TOAST chunk size\n");
if (!got_date_is_int)
- pg_log(ctx, PG_REPORT, " dates/times are integers?\n");
+ pg_log(PG_REPORT, " dates/times are integers?\n");
/* value added in Postgres 8.4 */
if (!got_float8_pass_by_value)
- pg_log(ctx, PG_REPORT, " float8 argument passing method\n");
+ pg_log(PG_REPORT, " float8 argument passing method\n");
- pg_log(ctx, PG_FATAL,
+ pg_log(PG_FATAL,
"Unable to continue without required control information, terminating\n");
}
}
* check to make sure the control data settings are compatible
*/
void
-check_control_data(migratorContext *ctx, ControlData *oldctrl,
+check_control_data(ControlData *oldctrl,
ControlData *newctrl)
{
if (oldctrl->align == 0 || oldctrl->align != newctrl->align)
- pg_log(ctx, PG_FATAL,
+ pg_log(PG_FATAL,
"old and new pg_controldata alignments are invalid or do not match\n");
if (oldctrl->blocksz == 0 || oldctrl->blocksz != newctrl->blocksz)
- pg_log(ctx, PG_FATAL,
+ pg_log(PG_FATAL,
"old and new pg_controldata block sizes are invalid or do not match\n");
if (oldctrl->largesz == 0 || oldctrl->largesz != newctrl->largesz)
- pg_log(ctx, PG_FATAL,
+ pg_log(PG_FATAL,
"old and new pg_controldata maximum relation segement sizes are invalid or do not match\n");
if (oldctrl->walsz == 0 || oldctrl->walsz != newctrl->walsz)
- pg_log(ctx, PG_FATAL,
+ pg_log(PG_FATAL,
"old and new pg_controldata WAL block sizes are invalid or do not match\n");
if (oldctrl->walseg == 0 || oldctrl->walseg != newctrl->walseg)
- pg_log(ctx, PG_FATAL,
+ pg_log(PG_FATAL,
"old and new pg_controldata WAL segment sizes are invalid or do not match\n");
if (oldctrl->ident == 0 || oldctrl->ident != newctrl->ident)
- pg_log(ctx, PG_FATAL,
+ pg_log(PG_FATAL,
"old and new pg_controldata maximum identifier lengths are invalid or do not match\n");
if (oldctrl->index == 0 || oldctrl->index != newctrl->index)
- pg_log(ctx, PG_FATAL,
+ pg_log(PG_FATAL,
"old and new pg_controldata maximum indexed columns are invalid or do not match\n");
if (oldctrl->toast == 0 || oldctrl->toast != newctrl->toast)
- pg_log(ctx, PG_FATAL,
+ pg_log(PG_FATAL,
"old and new pg_controldata maximum TOAST chunk sizes are invalid or do not match\n");
if (oldctrl->date_is_int != newctrl->date_is_int)
{
- pg_log(ctx, PG_WARNING,
+ pg_log(PG_WARNING,
"\nOld and new pg_controldata date/time storage types do not match.\n");
/*
* This is a common 8.3 -> 8.4 migration problem, so we are more
* verboase
*/
- pg_log(ctx, PG_FATAL,
+ pg_log(PG_FATAL,
"You will need to rebuild the new server with configure\n"
"--disable-integer-datetimes or get server binaries built\n"
"with those options.\n");
void
-rename_old_pg_control(migratorContext *ctx)
+rename_old_pg_control(void)
{
char old_path[MAXPGPATH],
new_path[MAXPGPATH];
- prep_status(ctx, "Adding \".old\" suffix to old global/pg_control");
+ prep_status("Adding \".old\" suffix to old global/pg_control");
- snprintf(old_path, sizeof(old_path), "%s/global/pg_control", ctx->old.pgdata);
- snprintf(new_path, sizeof(new_path), "%s/global/pg_control.old", ctx->old.pgdata);
+ snprintf(old_path, sizeof(old_path), "%s/global/pg_control", old_cluster.pgdata);
+ snprintf(new_path, sizeof(new_path), "%s/global/pg_control.old", old_cluster.pgdata);
if (pg_mv_file(old_path, new_path) != 0)
- pg_log(ctx, PG_FATAL, "Unable to rename %s to %s.\n", old_path, new_path);
- check_ok(ctx);
+ pg_log(PG_FATAL, "Unable to rename %s to %s.\n", old_path, new_path);
+ check_ok();
}
* It also does unsetenv() if val is NULL.
*/
static void
-putenv2(migratorContext *ctx, const char *var, const char *val)
+putenv2(const char *var, const char *val)
{
if (val)
{
#ifndef WIN32
- char *envstr = (char *) pg_malloc(ctx, strlen(var) +
+ char *envstr = (char *) pg_malloc(strlen(var) +
strlen(val) + 1);
sprintf(envstr, "%s=%s", var, val);
void
-generate_old_dump(migratorContext *ctx)
+generate_old_dump(void)
{
/* run new pg_dumpall binary */
- prep_status(ctx, "Creating catalog dump");
+ prep_status("Creating catalog dump");
/*
* --binary-upgrade records the width of dropped columns in pg_class, and
* restores the frozenid's for databases and relations.
*/
- exec_prog(ctx, true,
+ exec_prog(true,
SYSTEMQUOTE "\"%s/pg_dumpall\" --port %d --username \"%s\" "
"--schema-only --binary-upgrade > \"%s/" ALL_DUMP_FILE "\""
- SYSTEMQUOTE, ctx->new.bindir, ctx->old.port, ctx->user, ctx->cwd);
- check_ok(ctx);
+ SYSTEMQUOTE, new_cluster.bindir, old_cluster.port, os_info.user, os_info.cwd);
+ check_ok();
}
* an error during restore
*/
void
-split_old_dump(migratorContext *ctx)
+split_old_dump(void)
{
FILE *all_dump,
*globals_dump,
char filename[MAXPGPATH];
bool suppressed_username = false;
- snprintf(filename, sizeof(filename), "%s/%s", ctx->cwd, ALL_DUMP_FILE);
+ snprintf(filename, sizeof(filename), "%s/%s", os_info.cwd, ALL_DUMP_FILE);
if ((all_dump = fopen(filename, "r")) == NULL)
- pg_log(ctx, PG_FATAL, "Cannot open dump file %s\n", filename);
- snprintf(filename, sizeof(filename), "%s/%s", ctx->cwd, GLOBALS_DUMP_FILE);
+ pg_log(PG_FATAL, "Cannot open dump file %s\n", filename);
+ snprintf(filename, sizeof(filename), "%s/%s", os_info.cwd, GLOBALS_DUMP_FILE);
if ((globals_dump = fopen(filename, "w")) == NULL)
- pg_log(ctx, PG_FATAL, "Cannot write to dump file %s\n", filename);
- snprintf(filename, sizeof(filename), "%s/%s", ctx->cwd, DB_DUMP_FILE);
+ pg_log(PG_FATAL, "Cannot write to dump file %s\n", filename);
+ snprintf(filename, sizeof(filename), "%s/%s", os_info.cwd, DB_DUMP_FILE);
if ((db_dump = fopen(filename, "w")) == NULL)
- pg_log(ctx, PG_FATAL, "Cannot write to dump file %s\n", filename);
+ pg_log(PG_FATAL, "Cannot write to dump file %s\n", filename);
current_output = globals_dump;
/* patterns used to prevent our own username from being recreated */
snprintf(create_role_str, sizeof(create_role_str),
- "CREATE ROLE %s;", ctx->user);
+ "CREATE ROLE %s;", os_info.user);
snprintf(create_role_str_quote, sizeof(create_role_str_quote),
- "CREATE ROLE %s;", quote_identifier(ctx, ctx->user));
+ "CREATE ROLE %s;", quote_identifier(os_info.user));
while (fgets(line, sizeof(line), all_dump) != NULL)
{
#include <grp.h>
-static void check_data_dir(migratorContext *ctx, const char *pg_data);
-static void check_bin_dir(migratorContext *ctx, ClusterInfo *cluster);
-static int check_exec(migratorContext *ctx, const char *dir, const char *cmdName);
+static void check_data_dir(const char *pg_data);
+static void check_bin_dir(ClusterInfo *cluster);
+static int check_exec(const char *dir, const char *cmdName);
static const char *validate_exec(const char *path);
* instead of returning should an error occur.
*/
int
-exec_prog(migratorContext *ctx, bool throw_error, const char *fmt,...)
+exec_prog(bool throw_error, const char *fmt,...)
{
va_list args;
int result;
vsnprintf(cmd, MAXPGPATH, fmt, args);
va_end(args);
- pg_log(ctx, PG_INFO, "%s\n", cmd);
+ pg_log(PG_INFO, "%s\n", cmd);
result = system(cmd);
if (result != 0)
{
- pg_log(ctx, throw_error ? PG_FATAL : PG_INFO,
+ pg_log(throw_error ? PG_FATAL : PG_INFO,
"\nThere were problems executing %s\n", cmd);
return 1;
}
* The check is performed by looking for the existence of postmaster.pid file.
*/
bool
-is_server_running(migratorContext *ctx, const char *datadir)
+is_server_running(const char *datadir)
{
char path[MAXPGPATH];
int fd;
if ((fd = open(path, O_RDONLY, 0)) < 0)
{
if (errno != ENOENT)
- pg_log(ctx, PG_FATAL, "\ncould not open file \"%s\" for reading\n",
+ pg_log(PG_FATAL, "\ncould not open file \"%s\" for reading\n",
path);
return false;
* NOTE: May update the values of all parameters
*/
void
-verify_directories(migratorContext *ctx)
+verify_directories(void)
{
- prep_status(ctx, "Checking old data directory (%s)", ctx->old.pgdata);
- check_data_dir(ctx, ctx->old.pgdata);
- check_ok(ctx);
+ prep_status("Checking old data directory (%s)", old_cluster.pgdata);
+ check_data_dir(old_cluster.pgdata);
+ check_ok();
- prep_status(ctx, "Checking old bin directory (%s)", ctx->old.bindir);
- check_bin_dir(ctx, &ctx->old);
- check_ok(ctx);
+ prep_status("Checking old bin directory (%s)", old_cluster.bindir);
+ check_bin_dir(&old_cluster);
+ check_ok();
- prep_status(ctx, "Checking new data directory (%s)", ctx->new.pgdata);
- check_data_dir(ctx, ctx->new.pgdata);
- check_ok(ctx);
+ prep_status("Checking new data directory (%s)", new_cluster.pgdata);
+ check_data_dir(new_cluster.pgdata);
+ check_ok();
- prep_status(ctx, "Checking new bin directory (%s)", ctx->new.bindir);
- check_bin_dir(ctx, &ctx->new);
- check_ok(ctx);
+ prep_status("Checking new bin directory (%s)", new_cluster.bindir);
+ check_bin_dir(&new_cluster);
+ check_ok();
}
*
*/
static void
-check_data_dir(migratorContext *ctx, const char *pg_data)
+check_data_dir(const char *pg_data)
{
char subDirName[MAXPGPATH];
int subdirnum;
requiredSubdirs[subdirnum]);
if (stat(subDirName, &statBuf) != 0)
- report_status(ctx, PG_FATAL, "check for %s failed: %s",
+ report_status(PG_FATAL, "check for %s failed: %s",
requiredSubdirs[subdirnum], getErrorText(errno));
else if (!S_ISDIR(statBuf.st_mode))
- report_status(ctx, PG_FATAL, "%s is not a directory",
+ report_status(PG_FATAL, "%s is not a directory",
requiredSubdirs[subdirnum]);
}
}
* exit().
*/
static void
-check_bin_dir(migratorContext *ctx, ClusterInfo *cluster)
+check_bin_dir(ClusterInfo *cluster)
{
- check_exec(ctx, cluster->bindir, "postgres");
- check_exec(ctx, cluster->bindir, "psql");
- check_exec(ctx, cluster->bindir, "pg_ctl");
- check_exec(ctx, cluster->bindir, "pg_dumpall");
+ check_exec(cluster->bindir, "postgres");
+ check_exec(cluster->bindir, "psql");
+ check_exec(cluster->bindir, "pg_ctl");
+ check_exec(cluster->bindir, "pg_dumpall");
}
* a valid executable, this function returns 0 to indicated failure.
*/
static int
-check_exec(migratorContext *ctx, const char *dir, const char *cmdName)
+check_exec(const char *dir, const char *cmdName)
{
char path[MAXPGPATH];
const char *errMsg;
if ((errMsg = validate_exec(path)) == NULL)
return 1; /* 1 -> first alternative OK */
else
- pg_log(ctx, PG_FATAL, "check for %s failed - %s\n", cmdName, errMsg);
+ pg_log(PG_FATAL, "check for %s failed - %s\n", cmdName, errMsg);
return 0; /* 0 -> neither alternative is acceptable */
}
#endif
#ifndef HAVE_SCANDIR
-static int pg_scandir_internal(migratorContext *ctx, const char *dirname,
+static int pg_scandir_internal(const char *dirname,
struct dirent *** namelist,
int (*selector) (const struct dirent *));
#endif
* uses that pageConverter to do a page-by-page conversion.
*/
const char *
-copyAndUpdateFile(migratorContext *ctx, pageCnvCtx *pageConverter,
+copyAndUpdateFile(pageCnvCtx *pageConverter,
const char *src, const char *dst, bool force)
{
if (pageConverter == NULL)
* instead of copying the data from the old cluster to the new cluster.
*/
const char *
-linkAndUpdateFile(migratorContext *ctx, pageCnvCtx *pageConverter,
+linkAndUpdateFile(pageCnvCtx *pageConverter,
const char *src, const char *dst)
{
if (pageConverter != NULL)
* Wrapper for portable scandir functionality
*/
int
-pg_scandir(migratorContext *ctx, const char *dirname,
+pg_scandir(const char *dirname,
struct dirent *** namelist,
int (*selector) (const struct dirent *))
{
#ifndef HAVE_SCANDIR
- return pg_scandir_internal(ctx, dirname, namelist, selector);
+ return pg_scandir_internal(dirname, namelist, selector);
/*
* scandir() is originally from BSD 4.3, which had the third argument as
* .2, etc.) and should therefore be invoked a small number of times.
*/
static int
-pg_scandir_internal(migratorContext *ctx, const char *dirname,
+pg_scandir_internal(const char *dirname,
struct dirent *** namelist, int (*selector) (const struct dirent *))
{
DIR *dirdesc;
size_t entrysize;
if ((dirdesc = opendir(dirname)) == NULL)
- pg_log(ctx, PG_FATAL, "Could not open directory \"%s\": %m\n", dirname);
+ pg_log(PG_FATAL, "Could not open directory \"%s\": %m\n", dirname);
*namelist = NULL;
void
-check_hard_link(migratorContext *ctx)
+check_hard_link(void)
{
char existing_file[MAXPGPATH];
char new_link_file[MAXPGPATH];
- snprintf(existing_file, sizeof(existing_file), "%s/PG_VERSION", ctx->old.pgdata);
- snprintf(new_link_file, sizeof(new_link_file), "%s/PG_VERSION.linktest", ctx->new.pgdata);
+ snprintf(existing_file, sizeof(existing_file), "%s/PG_VERSION", old_cluster.pgdata);
+ snprintf(new_link_file, sizeof(new_link_file), "%s/PG_VERSION.linktest", new_cluster.pgdata);
unlink(new_link_file); /* might fail */
if (pg_link_file(existing_file, new_link_file) == -1)
{
- pg_log(ctx, PG_FATAL,
+ pg_log(PG_FATAL,
"Could not create hard link between old and new data directories: %s\n"
"In link mode the old and new data directories must be on the same file system volume.\n",
getErrorText(errno));
* backend behavior.
*/
void
-install_support_functions(migratorContext *ctx)
+install_support_functions(void)
{
int dbnum;
- prep_status(ctx, "Adding support functions to new cluster");
+ prep_status("Adding support functions to new cluster");
- for (dbnum = 0; dbnum < ctx->new.dbarr.ndbs; dbnum++)
+ for (dbnum = 0; dbnum < new_cluster.dbarr.ndbs; dbnum++)
{
- DbInfo *newdb = &ctx->new.dbarr.dbs[dbnum];
- PGconn *conn = connectToServer(ctx, newdb->db_name, CLUSTER_NEW);
+ DbInfo *newdb = &new_cluster.dbarr.dbs[dbnum];
+ PGconn *conn = connectToServer(newdb->db_name, CLUSTER_NEW);
/* suppress NOTICE of dropped objects */
- PQclear(executeQueryOrDie(ctx, conn,
+ PQclear(executeQueryOrDie(conn,
"SET client_min_messages = warning;"));
- PQclear(executeQueryOrDie(ctx, conn,
+ PQclear(executeQueryOrDie(conn,
"DROP SCHEMA IF EXISTS binary_upgrade CASCADE;"));
- PQclear(executeQueryOrDie(ctx, conn,
+ PQclear(executeQueryOrDie(conn,
"RESET client_min_messages;"));
- PQclear(executeQueryOrDie(ctx, conn,
+ PQclear(executeQueryOrDie(conn,
"CREATE SCHEMA binary_upgrade;"));
- PQclear(executeQueryOrDie(ctx, conn,
+ PQclear(executeQueryOrDie(conn,
"CREATE OR REPLACE FUNCTION "
" binary_upgrade.set_next_pg_type_oid(OID) "
"RETURNS VOID "
"AS '$libdir/pg_upgrade_support' "
"LANGUAGE C STRICT;"));
- PQclear(executeQueryOrDie(ctx, conn,
+ PQclear(executeQueryOrDie(conn,
"CREATE OR REPLACE FUNCTION "
" binary_upgrade.set_next_pg_type_array_oid(OID) "
"RETURNS VOID "
"AS '$libdir/pg_upgrade_support' "
"LANGUAGE C STRICT;"));
- PQclear(executeQueryOrDie(ctx, conn,
+ PQclear(executeQueryOrDie(conn,
"CREATE OR REPLACE FUNCTION "
" binary_upgrade.set_next_pg_type_toast_oid(OID) "
"RETURNS VOID "
"AS '$libdir/pg_upgrade_support' "
"LANGUAGE C STRICT;"));
- PQclear(executeQueryOrDie(ctx, conn,
+ PQclear(executeQueryOrDie(conn,
"CREATE OR REPLACE FUNCTION "
" binary_upgrade.set_next_heap_relfilenode(OID) "
"RETURNS VOID "
"AS '$libdir/pg_upgrade_support' "
"LANGUAGE C STRICT;"));
- PQclear(executeQueryOrDie(ctx, conn,
+ PQclear(executeQueryOrDie(conn,
"CREATE OR REPLACE FUNCTION "
" binary_upgrade.set_next_toast_relfilenode(OID) "
"RETURNS VOID "
"AS '$libdir/pg_upgrade_support' "
"LANGUAGE C STRICT;"));
- PQclear(executeQueryOrDie(ctx, conn,
+ PQclear(executeQueryOrDie(conn,
"CREATE OR REPLACE FUNCTION "
" binary_upgrade.set_next_index_relfilenode(OID) "
"RETURNS VOID "
"AS '$libdir/pg_upgrade_support' "
"LANGUAGE C STRICT;"));
- PQclear(executeQueryOrDie(ctx, conn,
+ PQclear(executeQueryOrDie(conn,
"CREATE OR REPLACE FUNCTION "
" binary_upgrade.add_pg_enum_label(OID, OID, NAME) "
"RETURNS VOID "
"LANGUAGE C STRICT;"));
PQfinish(conn);
}
- check_ok(ctx);
+ check_ok();
}
void
-uninstall_support_functions(migratorContext *ctx)
+uninstall_support_functions(void)
{
int dbnum;
- prep_status(ctx, "Removing support functions from new cluster");
+ prep_status("Removing support functions from new cluster");
- for (dbnum = 0; dbnum < ctx->new.dbarr.ndbs; dbnum++)
+ for (dbnum = 0; dbnum < new_cluster.dbarr.ndbs; dbnum++)
{
- DbInfo *newdb = &ctx->new.dbarr.dbs[dbnum];
- PGconn *conn = connectToServer(ctx, newdb->db_name, CLUSTER_NEW);
+ DbInfo *newdb = &new_cluster.dbarr.dbs[dbnum];
+ PGconn *conn = connectToServer(newdb->db_name, CLUSTER_NEW);
/* suppress NOTICE of dropped objects */
- PQclear(executeQueryOrDie(ctx, conn,
+ PQclear(executeQueryOrDie(conn,
"SET client_min_messages = warning;"));
- PQclear(executeQueryOrDie(ctx, conn,
+ PQclear(executeQueryOrDie(conn,
"DROP SCHEMA binary_upgrade CASCADE;"));
- PQclear(executeQueryOrDie(ctx, conn,
+ PQclear(executeQueryOrDie(conn,
"RESET client_min_messages;"));
PQfinish(conn);
}
- check_ok(ctx);
+ check_ok();
}
* We will later check that they all exist in the new installation.
*/
void
-get_loadable_libraries(migratorContext *ctx)
+get_loadable_libraries(void)
{
- ClusterInfo *active_cluster = &ctx->old;
+ ClusterInfo *active_cluster = &old_cluster;
PGresult **ress;
int totaltups;
int dbnum;
ress = (PGresult **)
- pg_malloc(ctx, active_cluster->dbarr.ndbs * sizeof(PGresult *));
+ pg_malloc(active_cluster->dbarr.ndbs * sizeof(PGresult *));
totaltups = 0;
/* Fetch all library names, removing duplicates within each DB */
for (dbnum = 0; dbnum < active_cluster->dbarr.ndbs; dbnum++)
{
DbInfo *active_db = &active_cluster->dbarr.dbs[dbnum];
- PGconn *conn = connectToServer(ctx, active_db->db_name, CLUSTER_OLD);
+ PGconn *conn = connectToServer(active_db->db_name, CLUSTER_OLD);
/* Fetch all libraries referenced in this DB */
- ress[dbnum] = executeQueryOrDie(ctx, conn,
+ ress[dbnum] = executeQueryOrDie(conn,
"SELECT DISTINCT probin "
"FROM pg_catalog.pg_proc "
"WHERE prolang = 13 /* C */ AND "
/* Allocate what's certainly enough space */
if (totaltups > 0)
- ctx->libraries = (char **) pg_malloc(ctx, totaltups * sizeof(char *));
+ os_info.libraries = (char **) pg_malloc(totaltups * sizeof(char *));
else
- ctx->libraries = NULL;
+ os_info.libraries = NULL;
/*
* Now remove duplicates across DBs. This is pretty inefficient code, but
for (n = 0; n < totaltups; n++)
{
- if (strcmp(lib, ctx->libraries[n]) == 0)
+ if (strcmp(lib, os_info.libraries[n]) == 0)
{
dup = true;
break;
}
}
if (!dup)
- ctx->libraries[totaltups++] = pg_strdup(ctx, lib);
+ os_info.libraries[totaltups++] = pg_strdup(lib);
}
PQclear(res);
}
- ctx->num_libraries = totaltups;
+ os_info.num_libraries = totaltups;
pg_free(ress);
}
* compatibility as well as presence.
*/
void
-check_loadable_libraries(migratorContext *ctx)
+check_loadable_libraries(void)
{
- PGconn *conn = connectToServer(ctx, "template1", CLUSTER_NEW);
+ PGconn *conn = connectToServer("template1", CLUSTER_NEW);
int libnum;
FILE *script = NULL;
bool found = false;
char output_path[MAXPGPATH];
- prep_status(ctx, "Checking for presence of required libraries");
+ prep_status("Checking for presence of required libraries");
snprintf(output_path, sizeof(output_path), "%s/loadable_libraries.txt",
- ctx->cwd);
+ os_info.cwd);
- for (libnum = 0; libnum < ctx->num_libraries; libnum++)
+ for (libnum = 0; libnum < os_info.num_libraries; libnum++)
{
- char *lib = ctx->libraries[libnum];
+ char *lib = os_info.libraries[libnum];
int llen = strlen(lib);
- char *cmd = (char *) pg_malloc(ctx, 8 + 2 * llen + 1);
+ char *cmd = (char *) pg_malloc(8 + 2 * llen + 1);
PGresult *res;
strcpy(cmd, "LOAD '");
{
found = true;
if (script == NULL && (script = fopen(output_path, "w")) == NULL)
- pg_log(ctx, PG_FATAL, "Could not create necessary file: %s\n",
+ pg_log(PG_FATAL, "Could not create necessary file: %s\n",
output_path);
fprintf(script, "Failed to load library: %s\n%s\n",
lib,
if (found)
{
fclose(script);
- pg_log(ctx, PG_REPORT, "fatal\n");
- pg_log(ctx, PG_FATAL,
+ pg_log(PG_REPORT, "fatal\n");
+ pg_log(PG_FATAL,
"| Your installation references loadable libraries that are missing\n"
"| from the new installation. You can add these libraries to\n"
"| the new installation, or remove the functions using them\n"
"| \"%s\".\n\n", output_path);
}
else
- check_ok(ctx);
+ check_ok();
}
#include "access/transam.h"
-static void get_db_infos(migratorContext *ctx, DbInfoArr *dbinfos,
+static void get_db_infos(DbInfoArr *dbinfos,
Cluster whichCluster);
-static void dbarr_print(migratorContext *ctx, DbInfoArr *arr,
+static void dbarr_print(DbInfoArr *arr,
Cluster whichCluster);
-static void relarr_print(migratorContext *ctx, RelInfoArr *arr);
-static void get_rel_infos(migratorContext *ctx, const DbInfo *dbinfo,
+static void relarr_print(RelInfoArr *arr);
+static void get_rel_infos(const DbInfo *dbinfo,
RelInfoArr *relarr, Cluster whichCluster);
static void relarr_free(RelInfoArr *rel_arr);
-static void map_rel(migratorContext *ctx, const RelInfo *oldrel,
+static void map_rel(const RelInfo *oldrel,
const RelInfo *newrel, const DbInfo *old_db,
const DbInfo *new_db, const char *olddata,
const char *newdata, FileNameMap *map);
-static void map_rel_by_id(migratorContext *ctx, Oid oldid, Oid newid,
+static void map_rel_by_id(Oid oldid, Oid newid,
const char *old_nspname, const char *old_relname,
const char *new_nspname, const char *new_relname,
const char *old_tablespace, const DbInfo *old_db,
const DbInfo *new_db, const char *olddata,
const char *newdata, FileNameMap *map);
-static RelInfo *relarr_lookup_reloid(migratorContext *ctx,
+static RelInfo *relarr_lookup_reloid(
RelInfoArr *rel_arr, Oid oid, Cluster whichCluster);
-static RelInfo *relarr_lookup_rel(migratorContext *ctx, RelInfoArr *rel_arr,
+static RelInfo *relarr_lookup_rel(RelInfoArr *rel_arr,
const char *nspname, const char *relname,
Cluster whichCluster);
* NOTE: Its the Caller's responsibility to free the returned array.
*/
FileNameMap *
-gen_db_file_maps(migratorContext *ctx, DbInfo *old_db, DbInfo *new_db,
+gen_db_file_maps(DbInfo *old_db, DbInfo *new_db,
int *nmaps, const char *old_pgdata, const char *new_pgdata)
{
FileNameMap *maps;
int relnum;
int num_maps = 0;
- maps = (FileNameMap *) pg_malloc(ctx, sizeof(FileNameMap) *
+ maps = (FileNameMap *) pg_malloc(sizeof(FileNameMap) *
new_db->rel_arr.nrels);
for (relnum = 0; relnum < new_db->rel_arr.nrels; relnum++)
if (strcmp(newrel->nspname, "pg_toast") == 0)
continue;
- oldrel = relarr_lookup_rel(ctx, &(old_db->rel_arr), newrel->nspname,
+ oldrel = relarr_lookup_rel(&(old_db->rel_arr), newrel->nspname,
newrel->relname, CLUSTER_OLD);
- map_rel(ctx, oldrel, newrel, old_db, new_db, old_pgdata, new_pgdata,
+ map_rel(oldrel, newrel, old_db, new_db, old_pgdata, new_pgdata,
maps + num_maps);
num_maps++;
newrel->reloid);
/* look them up in their respective arrays */
- old_toast = relarr_lookup_reloid(ctx, &old_db->rel_arr,
+ old_toast = relarr_lookup_reloid(&old_db->rel_arr,
oldrel->toastrelid, CLUSTER_OLD);
- new_toast = relarr_lookup_rel(ctx, &new_db->rel_arr,
+ new_toast = relarr_lookup_rel(&new_db->rel_arr,
"pg_toast", new_name, CLUSTER_NEW);
/* finally create a mapping for them */
- map_rel(ctx, old_toast, new_toast, old_db, new_db, old_pgdata, new_pgdata,
+ map_rel(old_toast, new_toast, old_db, new_db, old_pgdata, new_pgdata,
maps + num_maps);
num_maps++;
newrel->reloid);
/* look them up in their respective arrays */
- old_toast = relarr_lookup_rel(ctx, &old_db->rel_arr,
+ old_toast = relarr_lookup_rel(&old_db->rel_arr,
"pg_toast", old_name, CLUSTER_OLD);
- new_toast = relarr_lookup_rel(ctx, &new_db->rel_arr,
+ new_toast = relarr_lookup_rel(&new_db->rel_arr,
"pg_toast", new_name, CLUSTER_NEW);
/* finally create a mapping for them */
- map_rel(ctx, old_toast, new_toast, old_db, new_db, old_pgdata,
+ map_rel(old_toast, new_toast, old_db, new_db, old_pgdata,
new_pgdata, maps + num_maps);
num_maps++;
}
static void
-map_rel(migratorContext *ctx, const RelInfo *oldrel, const RelInfo *newrel,
+map_rel(const RelInfo *oldrel, const RelInfo *newrel,
const DbInfo *old_db, const DbInfo *new_db, const char *olddata,
const char *newdata, FileNameMap *map)
{
- map_rel_by_id(ctx, oldrel->relfilenode, newrel->relfilenode, oldrel->nspname,
+ map_rel_by_id(oldrel->relfilenode, newrel->relfilenode, oldrel->nspname,
oldrel->relname, newrel->nspname, newrel->relname, oldrel->tablespace, old_db,
new_db, olddata, newdata, map);
}
* fills a file node map structure and returns it in "map".
*/
static void
-map_rel_by_id(migratorContext *ctx, Oid oldid, Oid newid,
+map_rel_by_id(Oid oldid, Oid newid,
const char *old_nspname, const char *old_relname,
const char *new_nspname, const char *new_relname,
const char *old_tablespace, const DbInfo *old_db,
const DbInfo *new_db, const char *olddata,
const char *newdata, FileNameMap *map)
{
- map->new = newid;
- map->old = oldid;
+ map->old_relfilenode = oldid;
+ map->new_relfilenode = newid;
snprintf(map->old_nspname, sizeof(map->old_nspname), "%s", old_nspname);
snprintf(map->old_relname, sizeof(map->old_relname), "%s", old_relname);
* location
*/
snprintf(map->old_file, sizeof(map->old_file), "%s%s/%u", old_tablespace,
- ctx->old.tablespace_suffix, old_db->db_oid);
+ old_cluster.tablespace_suffix, old_db->db_oid);
snprintf(map->new_file, sizeof(map->new_file), "%s%s/%u", old_tablespace,
- ctx->new.tablespace_suffix, new_db->db_oid);
+ new_cluster.tablespace_suffix, new_db->db_oid);
}
}
void
-print_maps(migratorContext *ctx, FileNameMap *maps, int n, const char *dbName)
+print_maps(FileNameMap *maps, int n, const char *dbName)
{
- if (ctx->debug)
+ if (log.debug)
{
int mapnum;
- pg_log(ctx, PG_DEBUG, "mappings for db %s:\n", dbName);
+ pg_log(PG_DEBUG, "mappings for db %s:\n", dbName);
for (mapnum = 0; mapnum < n; mapnum++)
- pg_log(ctx, PG_DEBUG, "%s.%s:%u ==> %s.%s:%u\n",
- maps[mapnum].old_nspname, maps[mapnum].old_relname, maps[mapnum].old,
- maps[mapnum].new_nspname, maps[mapnum].new_relname, maps[mapnum].new);
+ pg_log(PG_DEBUG, "%s.%s:%u ==> %s.%s:%u\n",
+ maps[mapnum].old_nspname, maps[mapnum].old_relname,
+ maps[mapnum].old_relfilenode,
+ maps[mapnum].new_nspname, maps[mapnum].new_relname,
+ maps[mapnum].new_relfilenode);
- pg_log(ctx, PG_DEBUG, "\n\n");
+ pg_log(PG_DEBUG, "\n\n");
}
}
* databases.
*/
static void
-get_db_infos(migratorContext *ctx, DbInfoArr *dbinfs_arr, Cluster whichCluster)
+get_db_infos(DbInfoArr *dbinfs_arr, Cluster whichCluster)
{
- PGconn *conn = connectToServer(ctx, "template1", whichCluster);
+ PGconn *conn = connectToServer("template1", whichCluster);
PGresult *res;
int ntups;
int tupnum;
int i_oid;
int i_spclocation;
- res = executeQueryOrDie(ctx, conn,
+ res = executeQueryOrDie(conn,
"SELECT d.oid, d.datname, t.spclocation "
"FROM pg_catalog.pg_database d "
" LEFT OUTER JOIN pg_catalog.pg_tablespace t "
i_spclocation = PQfnumber(res, "spclocation");
ntups = PQntuples(res);
- dbinfos = (DbInfo *) pg_malloc(ctx, sizeof(DbInfo) * ntups);
+ dbinfos = (DbInfo *) pg_malloc(sizeof(DbInfo) * ntups);
for (tupnum = 0; tupnum < ntups; tupnum++)
{
* on the given "port". Assumes that server is already running.
*/
void
-get_db_and_rel_infos(migratorContext *ctx, DbInfoArr *db_arr, Cluster whichCluster)
+get_db_and_rel_infos(DbInfoArr *db_arr, Cluster whichCluster)
{
int dbnum;
- get_db_infos(ctx, db_arr, whichCluster);
+ get_db_infos(db_arr, whichCluster);
for (dbnum = 0; dbnum < db_arr->ndbs; dbnum++)
- get_rel_infos(ctx, &db_arr->dbs[dbnum],
+ get_rel_infos(&db_arr->dbs[dbnum],
&(db_arr->dbs[dbnum].rel_arr), whichCluster);
- if (ctx->debug)
- dbarr_print(ctx, db_arr, whichCluster);
+ if (log.debug)
+ dbarr_print(db_arr, whichCluster);
}
* FirstNormalObjectId belongs to the user
*/
static void
-get_rel_infos(migratorContext *ctx, const DbInfo *dbinfo,
+get_rel_infos(const DbInfo *dbinfo,
RelInfoArr *relarr, Cluster whichCluster)
{
- PGconn *conn = connectToServer(ctx, dbinfo->db_name, whichCluster);
+ PGconn *conn = connectToServer(dbinfo->db_name, whichCluster);
PGresult *res;
RelInfo *relinfos;
int ntups;
"ORDER BY n.nspname, c.relname;",
FirstNormalObjectId,
/* see the comment at the top of old_8_3_create_sequence_script() */
- (GET_MAJOR_VERSION(ctx->old.major_version) <= 803) ?
+ (GET_MAJOR_VERSION(old_cluster.major_version) <= 803) ?
"" : ", 'S'");
- res = executeQueryOrDie(ctx, conn, query);
+ res = executeQueryOrDie(conn, query);
ntups = PQntuples(res);
- relinfos = (RelInfo *) pg_malloc(ctx, sizeof(RelInfo) * ntups);
+ relinfos = (RelInfo *) pg_malloc(sizeof(RelInfo) * ntups);
i_oid = PQfnumber(res, "oid");
i_nspname = PQfnumber(res, "nspname");
* RelInfo structure.
*/
static RelInfo *
-relarr_lookup_rel(migratorContext *ctx, RelInfoArr *rel_arr,
+relarr_lookup_rel(RelInfoArr *rel_arr,
const char *nspname, const char *relname,
Cluster whichCluster)
{
strcmp(rel_arr->rels[relnum].relname, relname) == 0)
return &rel_arr->rels[relnum];
}
- pg_log(ctx, PG_FATAL, "Could not find %s.%s in %s cluster\n",
+ pg_log(PG_FATAL, "Could not find %s.%s in %s cluster\n",
nspname, relname, CLUSTERNAME(whichCluster));
return NULL;
}
* found.
*/
static RelInfo *
-relarr_lookup_reloid(migratorContext *ctx, RelInfoArr *rel_arr, Oid oid,
+relarr_lookup_reloid(RelInfoArr *rel_arr, Oid oid,
Cluster whichCluster)
{
int relnum;
if (rel_arr->rels[relnum].reloid == oid)
return &rel_arr->rels[relnum];
}
- pg_log(ctx, PG_FATAL, "Could not find %d in %s cluster\n",
+ pg_log(PG_FATAL, "Could not find %d in %s cluster\n",
oid, CLUSTERNAME(whichCluster));
return NULL;
}
static void
-dbarr_print(migratorContext *ctx, DbInfoArr *arr, Cluster whichCluster)
+dbarr_print(DbInfoArr *arr, Cluster whichCluster)
{
int dbnum;
- pg_log(ctx, PG_DEBUG, "%s databases\n", CLUSTERNAME(whichCluster));
+ pg_log(PG_DEBUG, "%s databases\n", CLUSTERNAME(whichCluster));
for (dbnum = 0; dbnum < arr->ndbs; dbnum++)
{
- pg_log(ctx, PG_DEBUG, "Database: %s\n", arr->dbs[dbnum].db_name);
- relarr_print(ctx, &arr->dbs[dbnum].rel_arr);
- pg_log(ctx, PG_DEBUG, "\n\n");
+ pg_log(PG_DEBUG, "Database: %s\n", arr->dbs[dbnum].db_name);
+ relarr_print(&arr->dbs[dbnum].rel_arr);
+ pg_log(PG_DEBUG, "\n\n");
}
}
static void
-relarr_print(migratorContext *ctx, RelInfoArr *arr)
+relarr_print(RelInfoArr *arr)
{
int relnum;
for (relnum = 0; relnum < arr->nrels; relnum++)
- pg_log(ctx, PG_DEBUG, "relname: %s.%s: reloid: %u reltblspace: %s\n",
+ pg_log(PG_DEBUG, "relname: %s.%s: reloid: %u reltblspace: %s\n",
arr->rels[relnum].nspname, arr->rels[relnum].relname,
arr->rels[relnum].reloid, arr->rels[relnum].tablespace);
}
#endif
-static void usage(migratorContext *ctx);
-static void validateDirectoryOption(migratorContext *ctx, char **dirpath,
+static void usage(void);
+static void validateDirectoryOption(char **dirpath,
char *envVarName, char *cmdLineOption, char *description);
-static void get_pkglibdirs(migratorContext *ctx);
-static char *get_pkglibdir(migratorContext *ctx, const char *bindir);
+static void get_pkglibdirs(void);
+static char *get_pkglibdir(const char *bindir);
+
+
+UserOpts user_opts;
/*
* and initializes the rest of the object.
*/
void
-parseCommandLine(migratorContext *ctx, int argc, char *argv[])
+parseCommandLine(int argc, char *argv[])
{
static struct option long_options[] = {
{"old-datadir", required_argument, NULL, 'd'},
if (getenv("PGUSER"))
{
- pg_free(ctx->user);
- ctx->user = pg_strdup(ctx, getenv("PGUSER"));
+ pg_free(os_info.user);
+ os_info.user = pg_strdup(getenv("PGUSER"));
}
- ctx->progname = get_progname(argv[0]);
- ctx->old.port = getenv("PGPORT") ? atoi(getenv("PGPORT")) : DEF_PGPORT;
- ctx->new.port = getenv("PGPORT") ? atoi(getenv("PGPORT")) : DEF_PGPORT;
+ os_info.progname = get_progname(argv[0]);
+ old_cluster.port = getenv("PGPORT") ? atoi(getenv("PGPORT")) : DEF_PGPORT;
+ new_cluster.port = getenv("PGPORT") ? atoi(getenv("PGPORT")) : DEF_PGPORT;
/* must save value, getenv()'s pointer is not stable */
- ctx->transfer_mode = TRANSFER_MODE_COPY;
+ user_opts.transfer_mode = TRANSFER_MODE_COPY;
/* user lookup and 'root' test must be split because of usage() */
- user_id = get_user_info(ctx, &ctx->user);
+ user_id = get_user_info(&os_info.user);
if (argc > 1)
{
if (strcmp(argv[1], "--help") == 0 || strcmp(argv[1], "-h") == 0 ||
strcmp(argv[1], "-?") == 0)
{
- usage(ctx);
- exit_nicely(ctx, false);
+ usage();
+ exit_nicely(false);
}
if (strcmp(argv[1], "--version") == 0 || strcmp(argv[1], "-V") == 0)
{
- pg_log(ctx, PG_REPORT, "pg_upgrade " PG_VERSION "\n");
- exit_nicely(ctx, false);
+ pg_log(PG_REPORT, "pg_upgrade " PG_VERSION "\n");
+ exit_nicely(false);
}
}
if (user_id == 0)
- pg_log(ctx, PG_FATAL, "%s: cannot be run as root\n", ctx->progname);
+ pg_log(PG_FATAL, "%s: cannot be run as root\n", os_info.progname);
- getcwd(ctx->cwd, MAXPGPATH);
+ getcwd(os_info.cwd, MAXPGPATH);
while ((option = getopt_long(argc, argv, "d:D:b:B:cgG:kl:p:P:u:v",
long_options, &optindex)) != -1)
switch (option)
{
case 'd':
- ctx->old.pgdata = pg_strdup(ctx, optarg);
+ old_cluster.pgdata = pg_strdup(optarg);
break;
case 'D':
- ctx->new.pgdata = pg_strdup(ctx, optarg);
+ new_cluster.pgdata = pg_strdup(optarg);
break;
case 'b':
- ctx->old.bindir = pg_strdup(ctx, optarg);
+ old_cluster.bindir = pg_strdup(optarg);
break;
case 'B':
- ctx->new.bindir = pg_strdup(ctx, optarg);
+ new_cluster.bindir = pg_strdup(optarg);
break;
case 'c':
- ctx->check = true;
+ user_opts.check = true;
break;
case 'g':
- pg_log(ctx, PG_REPORT, "Running in debug mode\n");
- ctx->debug = true;
+ pg_log(PG_REPORT, "Running in debug mode\n");
+ log.debug = true;
break;
case 'G':
- if ((ctx->debug_fd = fopen(optarg, "w")) == NULL)
+ if ((log.debug_fd = fopen(optarg, "w")) == NULL)
{
- pg_log(ctx, PG_FATAL, "cannot open debug file\n");
- exit_nicely(ctx, false);
+ pg_log(PG_FATAL, "cannot open debug file\n");
+ exit_nicely(false);
}
break;
case 'k':
- ctx->transfer_mode = TRANSFER_MODE_LINK;
+ user_opts.transfer_mode = TRANSFER_MODE_LINK;
break;
case 'l':
- ctx->logfile = pg_strdup(ctx, optarg);
+ log.filename = pg_strdup(optarg);
break;
case 'p':
- if ((ctx->old.port = atoi(optarg)) <= 0)
+ if ((old_cluster.port = atoi(optarg)) <= 0)
{
- pg_log(ctx, PG_FATAL, "invalid old port number\n");
- exit_nicely(ctx, false);
+ pg_log(PG_FATAL, "invalid old port number\n");
+ exit_nicely(false);
}
break;
case 'P':
- if ((ctx->new.port = atoi(optarg)) <= 0)
+ if ((new_cluster.port = atoi(optarg)) <= 0)
{
- pg_log(ctx, PG_FATAL, "invalid new port number\n");
- exit_nicely(ctx, false);
+ pg_log(PG_FATAL, "invalid new port number\n");
+ exit_nicely(false);
}
break;
case 'u':
- pg_free(ctx->user);
- ctx->user = pg_strdup(ctx, optarg);
+ pg_free(os_info.user);
+ os_info.user = pg_strdup(optarg);
break;
case 'v':
- pg_log(ctx, PG_REPORT, "Running in verbose mode\n");
- ctx->verbose = true;
+ pg_log(PG_REPORT, "Running in verbose mode\n");
+ log.verbose = true;
break;
default:
- pg_log(ctx, PG_FATAL,
+ pg_log(PG_FATAL,
"Try \"%s --help\" for more information.\n",
- ctx->progname);
+ os_info.progname);
break;
}
}
- if (ctx->logfile != NULL)
+ if (log.filename != NULL)
{
/*
* We must use append mode so output generated by child processes via
* start.
*/
/* truncate */
- if ((ctx->log_fd = fopen(ctx->logfile, "w")) == NULL)
- pg_log(ctx, PG_FATAL, "Cannot write to log file %s\n", ctx->logfile);
- fclose(ctx->log_fd);
- if ((ctx->log_fd = fopen(ctx->logfile, "a")) == NULL)
- pg_log(ctx, PG_FATAL, "Cannot write to log file %s\n", ctx->logfile);
+ if ((log.fd = fopen(log.filename, "w")) == NULL)
+ pg_log(PG_FATAL, "Cannot write to log file %s\n", log.filename);
+ fclose(log.fd);
+ if ((log.fd = fopen(log.filename, "a")) == NULL)
+ pg_log(PG_FATAL, "Cannot write to log file %s\n", log.filename);
}
else
- ctx->logfile = strdup(DEVNULL);
+ log.filename = strdup(DEVNULL);
/* if no debug file name, output to the terminal */
- if (ctx->debug && !ctx->debug_fd)
+ if (log.debug && !log.debug_fd)
{
- ctx->debug_fd = fopen(DEVTTY, "w");
- if (!ctx->debug_fd)
- pg_log(ctx, PG_FATAL, "Cannot write to terminal\n");
+ log.debug_fd = fopen(DEVTTY, "w");
+ if (!log.debug_fd)
+ pg_log(PG_FATAL, "Cannot write to terminal\n");
}
/* Get values from env if not already set */
- validateDirectoryOption(ctx, &ctx->old.pgdata, "OLDDATADIR", "-d",
+ validateDirectoryOption(&old_cluster.pgdata, "OLDDATADIR", "-d",
"old cluster data resides");
- validateDirectoryOption(ctx, &ctx->new.pgdata, "NEWDATADIR", "-D",
+ validateDirectoryOption(&new_cluster.pgdata, "NEWDATADIR", "-D",
"new cluster data resides");
- validateDirectoryOption(ctx, &ctx->old.bindir, "OLDBINDIR", "-b",
+ validateDirectoryOption(&old_cluster.bindir, "OLDBINDIR", "-b",
"old cluster binaries reside");
- validateDirectoryOption(ctx, &ctx->new.bindir, "NEWBINDIR", "-B",
+ validateDirectoryOption(&new_cluster.bindir, "NEWBINDIR", "-B",
"new cluster binaries reside");
- get_pkglibdirs(ctx);
+ get_pkglibdirs();
}
static void
-usage(migratorContext *ctx)
+usage(void)
{
printf(_("\nUsage: pg_upgrade [OPTIONS]...\n\
\n\
\n\
For example:\n\
pg_upgrade -d oldCluster/data -D newCluster/data -b oldCluster/bin -B newCluster/bin\n\
-or\n"), ctx->old.port, ctx->new.port, ctx->user);
+or\n"), old_cluster.port, new_cluster.port, os_info.user);
#ifndef WIN32
printf(_("\
$ export OLDDATADIR=oldCluster/data\n\
* user hasn't provided the required directory name.
*/
static void
-validateDirectoryOption(migratorContext *ctx, char **dirpath,
+validateDirectoryOption(char **dirpath,
char *envVarName, char *cmdLineOption, char *description)
{
if (*dirpath == NULL || (strlen(*dirpath) == 0))
const char *envVar;
if ((envVar = getenv(envVarName)) && strlen(envVar))
- *dirpath = pg_strdup(ctx, envVar);
+ *dirpath = pg_strdup(envVar);
else
{
- pg_log(ctx, PG_FATAL, "You must identify the directory where the %s\n"
+ pg_log(PG_FATAL, "You must identify the directory where the %s\n"
"Please use the %s command-line option or the %s environment variable\n",
description, cmdLineOption, envVarName);
}
static void
-get_pkglibdirs(migratorContext *ctx)
+get_pkglibdirs(void)
{
- ctx->old.libpath = get_pkglibdir(ctx, ctx->old.bindir);
- ctx->new.libpath = get_pkglibdir(ctx, ctx->new.bindir);
+ old_cluster.libpath = get_pkglibdir(old_cluster.bindir);
+ new_cluster.libpath = get_pkglibdir(new_cluster.bindir);
}
static char *
-get_pkglibdir(migratorContext *ctx, const char *bindir)
+get_pkglibdir(const char *bindir)
{
char cmd[MAXPGPATH];
char bufin[MAX_STRING];
snprintf(cmd, sizeof(cmd), "\"%s/pg_config\" --pkglibdir", bindir);
if ((output = popen(cmd, "r")) == NULL)
- pg_log(ctx, PG_FATAL, "Could not get pkglibdir data: %s\n",
+ pg_log(PG_FATAL, "Could not get pkglibdir data: %s\n",
getErrorText(errno));
fgets(bufin, sizeof(bufin), output);
if (bufin[i] == '\n')
bufin[i] = '\0';
- return pg_strdup(ctx, bufin);
+ return pg_strdup(bufin);
}
#ifdef PAGE_CONVERSION
-static const char *getPageVersion(migratorContext *ctx,
+static const char *getPageVersion(
uint16 *version, const char *pathName);
-static pageCnvCtx *loadConverterPlugin(migratorContext *ctx,
+static pageCnvCtx *loadConverterPlugin(
uint16 newPageVersion, uint16 oldPageVersion);
* string.
*/
const char *
-setupPageConverter(migratorContext *ctx, pageCnvCtx **result)
+setupPageConverter(pageCnvCtx **result)
{
uint16 oldPageVersion;
uint16 newPageVersion;
char dstName[MAXPGPATH];
char srcName[MAXPGPATH];
- snprintf(dstName, sizeof(dstName), "%s/global/%u", ctx->new.pgdata,
- ctx->new.pg_database_oid);
- snprintf(srcName, sizeof(srcName), "%s/global/%u", ctx->old.pgdata,
- ctx->old.pg_database_oid);
+ snprintf(dstName, sizeof(dstName), "%s/global/%u", new_cluster.pgdata,
+ new_cluster.pg_database_oid);
+ snprintf(srcName, sizeof(srcName), "%s/global/%u", old_cluster.pgdata,
+ old_cluster.pg_database_oid);
- if ((msg = getPageVersion(ctx, &oldPageVersion, srcName)) != NULL)
+ if ((msg = getPageVersion(&oldPageVersion, srcName)) != NULL)
return msg;
- if ((msg = getPageVersion(ctx, &newPageVersion, dstName)) != NULL)
+ if ((msg = getPageVersion(&newPageVersion, dstName)) != NULL)
return msg;
/*
* layout.
*/
- if ((converter = loadConverterPlugin(ctx, newPageVersion, oldPageVersion)) == NULL)
+ if ((converter = loadConverterPlugin(newPageVersion, oldPageVersion)) == NULL)
return "can't find plugin to convert from old page layout to new page layout";
else
{
* of a null-terminated string).
*/
static const char *
-getPageVersion(migratorContext *ctx, uint16 *version, const char *pathName)
+getPageVersion(uint16 *version, const char *pathName)
{
int relfd;
PageHeaderData page;
* is not found, this function returns NULL.
*/
static pageCnvCtx *
-loadConverterPlugin(migratorContext *ctx, uint16 newPageVersion, uint16 oldPageVersion)
+loadConverterPlugin(uint16 newPageVersion, uint16 oldPageVersion)
{
char pluginName[MAXPGPATH];
void *plugin;
return NULL;
else
{
- pageCnvCtx *result = (pageCnvCtx *) pg_malloc(ctx, sizeof(*result));
+ pageCnvCtx *result = (pageCnvCtx *) pg_malloc(sizeof(*result));
result->old.PageVersion = oldPageVersion;
result->new.PageVersion = newPageVersion;
#include <langinfo.h>
#endif
-static void disable_old_cluster(migratorContext *ctx);
-static void prepare_new_cluster(migratorContext *ctx);
-static void prepare_new_databases(migratorContext *ctx);
-static void create_new_objects(migratorContext *ctx);
-static void copy_clog_xlog_xid(migratorContext *ctx);
-static void set_frozenxids(migratorContext *ctx);
-static void setup(migratorContext *ctx, char *argv0, bool live_check);
-static void cleanup(migratorContext *ctx);
-
+static void disable_old_cluster(void);
+static void prepare_new_cluster(void);
+static void prepare_new_databases(void);
+static void create_new_objects(void);
+static void copy_clog_xlog_xid(void);
+static void set_frozenxids(void);
+static void setup(char *argv0, bool live_check);
+static void cleanup(void);
+
+ClusterInfo old_cluster, new_cluster;
+OSInfo os_info;
int
main(int argc, char **argv)
{
- migratorContext ctx;
char *sequence_script_file_name = NULL;
char *deletion_script_file_name = NULL;
bool live_check = false;
- memset(&ctx, 0, sizeof(ctx));
-
- parseCommandLine(&ctx, argc, argv);
+ parseCommandLine(argc, argv);
- output_check_banner(&ctx, &live_check);
+ output_check_banner(&live_check);
- setup(&ctx, argv[0], live_check);
+ setup(argv[0], live_check);
- check_cluster_versions(&ctx);
- check_cluster_compatibility(&ctx, live_check);
+ check_cluster_versions();
+ check_cluster_compatibility(live_check);
- check_old_cluster(&ctx, live_check, &sequence_script_file_name);
+ check_old_cluster(live_check, &sequence_script_file_name);
/* -- NEW -- */
- start_postmaster(&ctx, CLUSTER_NEW, false);
+ start_postmaster(CLUSTER_NEW, false);
- check_new_cluster(&ctx);
- report_clusters_compatible(&ctx);
+ check_new_cluster();
+ report_clusters_compatible();
- pg_log(&ctx, PG_REPORT, "\nPerforming Migration\n");
- pg_log(&ctx, PG_REPORT, "--------------------\n");
+ pg_log(PG_REPORT, "\nPerforming Migration\n");
+ pg_log(PG_REPORT, "--------------------\n");
- disable_old_cluster(&ctx);
- prepare_new_cluster(&ctx);
+ disable_old_cluster();
+ prepare_new_cluster();
- stop_postmaster(&ctx, false, false);
+ stop_postmaster(false, false);
/*
* Destructive Changes to New Cluster
*/
- copy_clog_xlog_xid(&ctx);
+ copy_clog_xlog_xid();
/* New now using xids of the old system */
- prepare_new_databases(&ctx);
+ prepare_new_databases();
- create_new_objects(&ctx);
+ create_new_objects();
- transfer_all_new_dbs(&ctx, &ctx.old.dbarr, &ctx.new.dbarr,
- ctx.old.pgdata, ctx.new.pgdata);
+ transfer_all_new_dbs(&old_cluster.dbarr, &new_cluster.dbarr,
+ old_cluster.pgdata, new_cluster.pgdata);
/*
* Assuming OIDs are only used in system tables, there is no need to
* the old system, but we do it anyway just in case. We do it late here
* because there is no need to have the schema load use new oids.
*/
- prep_status(&ctx, "Setting next oid for new cluster");
- exec_prog(&ctx, true, SYSTEMQUOTE "\"%s/pg_resetxlog\" -o %u \"%s\" > "
+ prep_status("Setting next oid for new cluster");
+ exec_prog(true, SYSTEMQUOTE "\"%s/pg_resetxlog\" -o %u \"%s\" > "
DEVNULL SYSTEMQUOTE,
- ctx.new.bindir, ctx.old.controldata.chkpnt_nxtoid, ctx.new.pgdata);
- check_ok(&ctx);
+ new_cluster.bindir, old_cluster.controldata.chkpnt_nxtoid, new_cluster.pgdata);
+ check_ok();
- create_script_for_old_cluster_deletion(&ctx, &deletion_script_file_name);
+ create_script_for_old_cluster_deletion(&deletion_script_file_name);
- issue_warnings(&ctx, sequence_script_file_name);
+ issue_warnings(sequence_script_file_name);
- pg_log(&ctx, PG_REPORT, "\nUpgrade complete\n");
- pg_log(&ctx, PG_REPORT, "----------------\n");
+ pg_log(PG_REPORT, "\nUpgrade complete\n");
+ pg_log(PG_REPORT, "----------------\n");
- output_completion_banner(&ctx, deletion_script_file_name);
+ output_completion_banner(deletion_script_file_name);
pg_free(deletion_script_file_name);
pg_free(sequence_script_file_name);
- cleanup(&ctx);
+ cleanup();
return 0;
}
static void
-setup(migratorContext *ctx, char *argv0, bool live_check)
+setup(char *argv0, bool live_check)
{
char exec_path[MAXPGPATH]; /* full path to my executable */
* make sure the user has a clean environment, otherwise, we may confuse
* libpq when we connect to one (or both) of the servers.
*/
- check_for_libpq_envvars(ctx);
+ check_for_libpq_envvars();
- verify_directories(ctx);
+ verify_directories();
/* no postmasters should be running */
- if (!live_check && is_server_running(ctx, ctx->old.pgdata))
+ if (!live_check && is_server_running(old_cluster.pgdata))
{
- pg_log(ctx, PG_FATAL, "There seems to be a postmaster servicing the old cluster.\n"
+ pg_log(PG_FATAL, "There seems to be a postmaster servicing the old cluster.\n"
"Please shutdown that postmaster and try again.\n");
}
/* same goes for the new postmaster */
- if (is_server_running(ctx, ctx->new.pgdata))
+ if (is_server_running(new_cluster.pgdata))
{
- pg_log(ctx, PG_FATAL, "There seems to be a postmaster servicing the new cluster.\n"
+ pg_log(PG_FATAL, "There seems to be a postmaster servicing the new cluster.\n"
"Please shutdown that postmaster and try again.\n");
}
/* get path to pg_upgrade executable */
if (find_my_exec(argv0, exec_path) < 0)
- pg_log(ctx, PG_FATAL, "Could not get pathname to pg_upgrade: %s\n", getErrorText(errno));
+ pg_log(PG_FATAL, "Could not get pathname to pg_upgrade: %s\n", getErrorText(errno));
/* Trim off program name and keep just path */
*last_dir_separator(exec_path) = '\0';
canonicalize_path(exec_path);
- ctx->exec_path = pg_strdup(ctx, exec_path);
+ os_info.exec_path = pg_strdup(exec_path);
}
static void
-disable_old_cluster(migratorContext *ctx)
+disable_old_cluster(void)
{
/* rename pg_control so old server cannot be accidentally started */
- rename_old_pg_control(ctx);
+ rename_old_pg_control();
}
static void
-prepare_new_cluster(migratorContext *ctx)
+prepare_new_cluster(void)
{
/*
* It would make more sense to freeze after loading the schema, but that
* would cause us to lose the frozenids restored by the load. We use
* --analyze so autovacuum doesn't update statistics later
*/
- prep_status(ctx, "Analyzing all rows in the new cluster");
- exec_prog(ctx, true,
+ prep_status("Analyzing all rows in the new cluster");
+ exec_prog(true,
SYSTEMQUOTE "\"%s/vacuumdb\" --port %d --username \"%s\" "
"--all --analyze >> %s 2>&1" SYSTEMQUOTE,
- ctx->new.bindir, ctx->new.port, ctx->user, ctx->logfile);
- check_ok(ctx);
+ new_cluster.bindir, new_cluster.port, os_info.user, log.filename);
+ check_ok();
/*
* We do freeze after analyze so pg_statistic is also frozen. template0 is
* datfrozenxid and relfrozenxids later to match the new xid counter
* later.
*/
- prep_status(ctx, "Freezing all rows on the new cluster");
- exec_prog(ctx, true,
+ prep_status("Freezing all rows on the new cluster");
+ exec_prog(true,
SYSTEMQUOTE "\"%s/vacuumdb\" --port %d --username \"%s\" "
"--all --freeze >> %s 2>&1" SYSTEMQUOTE,
- ctx->new.bindir, ctx->new.port, ctx->user, ctx->logfile);
- check_ok(ctx);
+ new_cluster.bindir, new_cluster.port, os_info.user, log.filename);
+ check_ok();
- get_pg_database_relfilenode(ctx, CLUSTER_NEW);
+ get_pg_database_relfilenode(CLUSTER_NEW);
}
static void
-prepare_new_databases(migratorContext *ctx)
+prepare_new_databases(void)
{
/* -- NEW -- */
- start_postmaster(ctx, CLUSTER_NEW, false);
+ start_postmaster(CLUSTER_NEW, false);
/*
* We set autovacuum_freeze_max_age to its maximum value so autovacuum
* set.
*/
- set_frozenxids(ctx);
+ set_frozenxids();
/*
* We have to create the databases first so we can create the toast table
* placeholder relfiles.
*/
- prep_status(ctx, "Creating databases in the new cluster");
- exec_prog(ctx, true,
+ prep_status("Creating databases in the new cluster");
+ exec_prog(true,
SYSTEMQUOTE "\"%s/psql\" --set ON_ERROR_STOP=on "
/* --no-psqlrc prevents AUTOCOMMIT=off */
"--no-psqlrc --port %d --username \"%s\" "
"-f \"%s/%s\" --dbname template1 >> \"%s\"" SYSTEMQUOTE,
- ctx->new.bindir, ctx->new.port, ctx->user, ctx->cwd,
- GLOBALS_DUMP_FILE, ctx->logfile);
- check_ok(ctx);
+ new_cluster.bindir, new_cluster.port, os_info.user, os_info.cwd,
+ GLOBALS_DUMP_FILE, log.filename);
+ check_ok();
- get_db_and_rel_infos(ctx, &ctx->new.dbarr, CLUSTER_NEW);
+ get_db_and_rel_infos(&new_cluster.dbarr, CLUSTER_NEW);
- stop_postmaster(ctx, false, false);
+ stop_postmaster(false, false);
}
static void
-create_new_objects(migratorContext *ctx)
+create_new_objects(void)
{
/* -- NEW -- */
- start_postmaster(ctx, CLUSTER_NEW, false);
+ start_postmaster(CLUSTER_NEW, false);
- install_support_functions(ctx);
+ install_support_functions();
- prep_status(ctx, "Restoring database schema to new cluster");
- exec_prog(ctx, true,
+ prep_status("Restoring database schema to new cluster");
+ exec_prog(true,
SYSTEMQUOTE "\"%s/psql\" --set ON_ERROR_STOP=on "
"--no-psqlrc --port %d --username \"%s\" "
"-f \"%s/%s\" --dbname template1 >> \"%s\"" SYSTEMQUOTE,
- ctx->new.bindir, ctx->new.port, ctx->user, ctx->cwd,
- DB_DUMP_FILE, ctx->logfile);
- check_ok(ctx);
+ new_cluster.bindir, new_cluster.port, os_info.user, os_info.cwd,
+ DB_DUMP_FILE, log.filename);
+ check_ok();
/* regenerate now that we have db schemas */
- dbarr_free(&ctx->new.dbarr);
- get_db_and_rel_infos(ctx, &ctx->new.dbarr, CLUSTER_NEW);
+ dbarr_free(&new_cluster.dbarr);
+ get_db_and_rel_infos(&new_cluster.dbarr, CLUSTER_NEW);
- uninstall_support_functions(ctx);
+ uninstall_support_functions();
- stop_postmaster(ctx, false, false);
+ stop_postmaster(false, false);
}
static void
-copy_clog_xlog_xid(migratorContext *ctx)
+copy_clog_xlog_xid(void)
{
char old_clog_path[MAXPGPATH];
char new_clog_path[MAXPGPATH];
/* copy old commit logs to new data dir */
- prep_status(ctx, "Deleting new commit clogs");
+ prep_status("Deleting new commit clogs");
- snprintf(old_clog_path, sizeof(old_clog_path), "%s/pg_clog", ctx->old.pgdata);
- snprintf(new_clog_path, sizeof(new_clog_path), "%s/pg_clog", ctx->new.pgdata);
+ snprintf(old_clog_path, sizeof(old_clog_path), "%s/pg_clog", old_cluster.pgdata);
+ snprintf(new_clog_path, sizeof(new_clog_path), "%s/pg_clog", new_cluster.pgdata);
if (rmtree(new_clog_path, true) != true)
- pg_log(ctx, PG_FATAL, "Unable to delete directory %s\n", new_clog_path);
- check_ok(ctx);
+ pg_log(PG_FATAL, "Unable to delete directory %s\n", new_clog_path);
+ check_ok();
- prep_status(ctx, "Copying old commit clogs to new server");
+ prep_status("Copying old commit clogs to new server");
/* libpgport's copydir() doesn't work in FRONTEND code */
#ifndef WIN32
- exec_prog(ctx, true, SYSTEMQUOTE "%s \"%s\" \"%s\"" SYSTEMQUOTE,
+ exec_prog(true, SYSTEMQUOTE "%s \"%s\" \"%s\"" SYSTEMQUOTE,
"cp -Rf",
#else
/* flags: everything, no confirm, quiet, overwrite read-only */
- exec_prog(ctx, true, SYSTEMQUOTE "%s \"%s\" \"%s\\\"" SYSTEMQUOTE,
+ exec_prog(true, SYSTEMQUOTE "%s \"%s\" \"%s\\\"" SYSTEMQUOTE,
"xcopy /e /y /q /r",
#endif
old_clog_path, new_clog_path);
- check_ok(ctx);
+ check_ok();
/* set the next transaction id of the new cluster */
- prep_status(ctx, "Setting next transaction id for new cluster");
- exec_prog(ctx, true, SYSTEMQUOTE "\"%s/pg_resetxlog\" -f -x %u \"%s\" > " DEVNULL SYSTEMQUOTE,
- ctx->new.bindir, ctx->old.controldata.chkpnt_nxtxid, ctx->new.pgdata);
- check_ok(ctx);
+ prep_status("Setting next transaction id for new cluster");
+ exec_prog(true, SYSTEMQUOTE "\"%s/pg_resetxlog\" -f -x %u \"%s\" > " DEVNULL SYSTEMQUOTE,
+ new_cluster.bindir, old_cluster.controldata.chkpnt_nxtxid, new_cluster.pgdata);
+ check_ok();
/* now reset the wal archives in the new cluster */
- prep_status(ctx, "Resetting WAL archives");
- exec_prog(ctx, true, SYSTEMQUOTE "\"%s/pg_resetxlog\" -l %u,%u,%u \"%s\" >> \"%s\" 2>&1" SYSTEMQUOTE,
- ctx->new.bindir, ctx->old.controldata.chkpnt_tli,
- ctx->old.controldata.logid, ctx->old.controldata.nxtlogseg,
- ctx->new.pgdata, ctx->logfile);
- check_ok(ctx);
+ prep_status("Resetting WAL archives");
+ exec_prog(true, SYSTEMQUOTE "\"%s/pg_resetxlog\" -l %u,%u,%u \"%s\" >> \"%s\" 2>&1" SYSTEMQUOTE,
+ new_cluster.bindir, old_cluster.controldata.chkpnt_tli,
+ old_cluster.controldata.logid, old_cluster.controldata.nxtlogseg,
+ new_cluster.pgdata, log.filename);
+ check_ok();
}
*/
static
void
-set_frozenxids(migratorContext *ctx)
+set_frozenxids(void)
{
int dbnum;
PGconn *conn,
int i_datname;
int i_datallowconn;
- prep_status(ctx, "Setting frozenxid counters in new cluster");
+ prep_status("Setting frozenxid counters in new cluster");
- conn_template1 = connectToServer(ctx, "template1", CLUSTER_NEW);
+ conn_template1 = connectToServer("template1", CLUSTER_NEW);
/* set pg_database.datfrozenxid */
- PQclear(executeQueryOrDie(ctx, conn_template1,
+ PQclear(executeQueryOrDie(conn_template1,
"UPDATE pg_catalog.pg_database "
"SET datfrozenxid = '%u'",
- ctx->old.controldata.chkpnt_nxtxid));
+ old_cluster.controldata.chkpnt_nxtxid));
/* get database names */
- dbres = executeQueryOrDie(ctx, conn_template1,
+ dbres = executeQueryOrDie(conn_template1,
"SELECT datname, datallowconn "
"FROM pg_catalog.pg_database");
* change datallowconn.
*/
if (strcmp(datallowconn, "f") == 0)
- PQclear(executeQueryOrDie(ctx, conn_template1,
+ PQclear(executeQueryOrDie(conn_template1,
"UPDATE pg_catalog.pg_database "
"SET datallowconn = true "
"WHERE datname = '%s'", datname));
- conn = connectToServer(ctx, datname, CLUSTER_NEW);
+ conn = connectToServer(datname, CLUSTER_NEW);
/* set pg_class.relfrozenxid */
- PQclear(executeQueryOrDie(ctx, conn,
+ PQclear(executeQueryOrDie(conn,
"UPDATE pg_catalog.pg_class "
"SET relfrozenxid = '%u' "
/* only heap and TOAST are vacuumed */
"WHERE relkind IN ('r', 't')",
- ctx->old.controldata.chkpnt_nxtxid));
+ old_cluster.controldata.chkpnt_nxtxid));
PQfinish(conn);
/* Reset datallowconn flag */
if (strcmp(datallowconn, "f") == 0)
- PQclear(executeQueryOrDie(ctx, conn_template1,
+ PQclear(executeQueryOrDie(conn_template1,
"UPDATE pg_catalog.pg_database "
"SET datallowconn = false "
"WHERE datname = '%s'", datname));
PQfinish(conn_template1);
- check_ok(ctx);
+ check_ok();
}
static void
-cleanup(migratorContext *ctx)
+cleanup(void)
{
int tblnum;
char filename[MAXPGPATH];
- for (tblnum = 0; tblnum < ctx->num_tablespaces; tblnum++)
- pg_free(ctx->tablespaces[tblnum]);
- pg_free(ctx->tablespaces);
-
- dbarr_free(&ctx->old.dbarr);
- dbarr_free(&ctx->new.dbarr);
- pg_free(ctx->logfile);
- pg_free(ctx->user);
- pg_free(ctx->old.major_version_str);
- pg_free(ctx->new.major_version_str);
- pg_free(ctx->old.controldata.lc_collate);
- pg_free(ctx->new.controldata.lc_collate);
- pg_free(ctx->old.controldata.lc_ctype);
- pg_free(ctx->new.controldata.lc_ctype);
- pg_free(ctx->old.controldata.encoding);
- pg_free(ctx->new.controldata.encoding);
- pg_free(ctx->old.tablespace_suffix);
- pg_free(ctx->new.tablespace_suffix);
-
- if (ctx->log_fd != NULL)
+ for (tblnum = 0; tblnum < os_info.num_tablespaces; tblnum++)
+ pg_free(os_info.tablespaces[tblnum]);
+ pg_free(os_info.tablespaces);
+
+ dbarr_free(&old_cluster.dbarr);
+ dbarr_free(&new_cluster.dbarr);
+ pg_free(log.filename);
+ pg_free(os_info.user);
+ pg_free(old_cluster.major_version_str);
+ pg_free(new_cluster.major_version_str);
+ pg_free(old_cluster.controldata.lc_collate);
+ pg_free(new_cluster.controldata.lc_collate);
+ pg_free(old_cluster.controldata.lc_ctype);
+ pg_free(new_cluster.controldata.lc_ctype);
+ pg_free(old_cluster.controldata.encoding);
+ pg_free(new_cluster.controldata.encoding);
+ pg_free(old_cluster.tablespace_suffix);
+ pg_free(new_cluster.tablespace_suffix);
+
+ if (log.fd != NULL)
{
- fclose(ctx->log_fd);
- ctx->log_fd = NULL;
+ fclose(log.fd);
+ log.fd = NULL;
}
- if (ctx->debug_fd)
- fclose(ctx->debug_fd);
+ if (log.debug_fd)
+ fclose(log.debug_fd);
- snprintf(filename, sizeof(filename), "%s/%s", ctx->cwd, ALL_DUMP_FILE);
+ snprintf(filename, sizeof(filename), "%s/%s", os_info.cwd, ALL_DUMP_FILE);
unlink(filename);
- snprintf(filename, sizeof(filename), "%s/%s", ctx->cwd, GLOBALS_DUMP_FILE);
+ snprintf(filename, sizeof(filename), "%s/%s", os_info.cwd, GLOBALS_DUMP_FILE);
unlink(filename);
- snprintf(filename, sizeof(filename), "%s/%s", ctx->cwd, DB_DUMP_FILE);
+ snprintf(filename, sizeof(filename), "%s/%s", os_info.cwd, DB_DUMP_FILE);
unlink(filename);
}
#endif
#define CLUSTERNAME(cluster) ((cluster) == CLUSTER_OLD ? "old" : "new")
+#define ACTIVE_CLUSTER(cluster) (((cluster) == CLUSTER_OLD) ? \
+ &old_cluster : &new_cluster)
#define atooid(x) ((Oid) strtoul((x), NULL, 10))
*/
typedef struct
{
- Oid old; /* Relfilenode of the old relation */
- Oid new; /* Relfilenode of the new relation */
+ Oid old_relfilenode; /* Relfilenode of the old relation */
+ Oid new_relfilenode; /* Relfilenode of the new relation */
char old_file[MAXPGPATH];
char new_file[MAXPGPATH];
char old_nspname[NAMEDATALEN]; /* old name of the namespace */
/*
- * migratorContext
- *
- * We create a migratorContext object to store all of the information
- * that we need to migrate a single cluster.
+ * Log
+*/
+typedef struct
+{
+ char *filename; /* name of log file (may be /dev/null) */
+ FILE *fd; /* log FILE */
+ bool debug; /* TRUE -> log more information */
+ FILE *debug_fd; /* debug-level log FILE */
+ bool verbose; /* TRUE -> be verbose in messages */
+} Log;
+
+
+/*
+ * UserOpts
+*/
+typedef struct
+{
+ bool check; /* TRUE -> ask user for permission to make
+ * changes */
+ transferMode transfer_mode; /* copy files or link them? */
+} UserOpts;
+
+
+/*
+ * OSInfo
*/
typedef struct
{
- ClusterInfo old,
- new; /* old and new cluster information */
const char *progname; /* complete pathname for this program */
char *exec_path; /* full path to my executable */
char *user; /* username for clusters */
int num_libraries;
pgpid_t postmasterPID; /* PID of currently running postmaster */
Cluster running_cluster;
-
- char *logfile; /* name of log file (may be /dev/null) */
- FILE *log_fd; /* log FILE */
- FILE *debug_fd; /* debug-level log FILE */
- bool check; /* TRUE -> ask user for permission to make
- * changes */
- bool verbose; /* TRUE -> be verbose in messages */
- bool debug; /* TRUE -> log more information */
- transferMode transfer_mode; /* copy files or link them? */
-} migratorContext;
+} OSInfo;
/*
* Global variables
*/
+extern Log log;
+extern UserOpts user_opts;
+extern ClusterInfo old_cluster, new_cluster;
+extern OSInfo os_info;
extern char scandir_file_pattern[];
/* check.c */
-void output_check_banner(migratorContext *ctx, bool *live_check);
-void check_old_cluster(migratorContext *ctx, bool live_check,
+void output_check_banner(bool *live_check);
+void check_old_cluster(bool live_check,
char **sequence_script_file_name);
-void check_new_cluster(migratorContext *ctx);
-void report_clusters_compatible(migratorContext *ctx);
-void issue_warnings(migratorContext *ctx,
+void check_new_cluster(void);
+void report_clusters_compatible(void);
+void issue_warnings(
char *sequence_script_file_name);
-void output_completion_banner(migratorContext *ctx,
+void output_completion_banner(
char *deletion_script_file_name);
-void check_cluster_versions(migratorContext *ctx);
-void check_cluster_compatibility(migratorContext *ctx, bool live_check);
-void create_script_for_old_cluster_deletion(migratorContext *ctx,
- char **deletion_script_file_name);
+void check_cluster_versions(void);
+void check_cluster_compatibility(bool live_check);
+void create_script_for_old_cluster_deletion(char **deletion_script_file_name);
/* controldata.c */
-void get_control_data(migratorContext *ctx, ClusterInfo *cluster, bool live_check);
-void check_control_data(migratorContext *ctx, ControlData *oldctrl,
+void get_control_data(ClusterInfo *cluster, bool live_check);
+void check_control_data(ControlData *oldctrl,
ControlData *newctrl);
/* dump.c */
-void generate_old_dump(migratorContext *ctx);
-void split_old_dump(migratorContext *ctx);
+void generate_old_dump(void);
+void split_old_dump(void);
/* exec.c */
-int exec_prog(migratorContext *ctx, bool throw_error,
+int exec_prog(bool throw_error,
const char *cmd,...);
-void verify_directories(migratorContext *ctx);
-bool is_server_running(migratorContext *ctx, const char *datadir);
-void rename_old_pg_control(migratorContext *ctx);
+void verify_directories(void);
+bool is_server_running(const char *datadir);
+void rename_old_pg_control(void);
/* file.c */
pluginShutdown shutdown; /* Pointer to plugin's shutdown function */
} pageCnvCtx;
-const char *setupPageConverter(migratorContext *ctx, pageCnvCtx **result);
+const char *setupPageConverter(pageCnvCtx **result);
#else
/* dummy */
typedef void *pageCnvCtx;
#endif
int dir_matching_filenames(const struct dirent * scan_ent);
-int pg_scandir(migratorContext *ctx, const char *dirname,
+int pg_scandir(const char *dirname,
struct dirent *** namelist,
int (*selector) (const struct dirent *));
-const char *copyAndUpdateFile(migratorContext *ctx,
+const char *copyAndUpdateFile(
pageCnvCtx *pageConverter, const char *src,
const char *dst, bool force);
-const char *linkAndUpdateFile(migratorContext *ctx,
+const char *linkAndUpdateFile(
pageCnvCtx *pageConverter, const char *src, const char *dst);
-void check_hard_link(migratorContext *ctx);
+void check_hard_link(void);
/* function.c */
-void install_support_functions(migratorContext *ctx);
-void uninstall_support_functions(migratorContext *ctx);
-void get_loadable_libraries(migratorContext *ctx);
-void check_loadable_libraries(migratorContext *ctx);
+void install_support_functions(void);
+void uninstall_support_functions(void);
+void get_loadable_libraries(void);
+void check_loadable_libraries(void);
/* info.c */
-FileNameMap *gen_db_file_maps(migratorContext *ctx, DbInfo *old_db,
+FileNameMap *gen_db_file_maps(DbInfo *old_db,
DbInfo *new_db, int *nmaps, const char *old_pgdata,
const char *new_pgdata);
-void get_db_and_rel_infos(migratorContext *ctx, DbInfoArr *db_arr,
+void get_db_and_rel_infos(DbInfoArr *db_arr,
Cluster whichCluster);
DbInfo *dbarr_lookup_db(DbInfoArr *db_arr, const char *db_name);
void dbarr_free(DbInfoArr *db_arr);
-void print_maps(migratorContext *ctx, FileNameMap *maps, int n,
+void print_maps(FileNameMap *maps, int n,
const char *dbName);
/* option.c */
-void parseCommandLine(migratorContext *ctx, int argc, char *argv[]);
+void parseCommandLine(int argc, char *argv[]);
/* relfilenode.c */
-void get_pg_database_relfilenode(migratorContext *ctx, Cluster whichCluster);
-const char *transfer_all_new_dbs(migratorContext *ctx, DbInfoArr *olddb_arr,
+void get_pg_database_relfilenode(Cluster whichCluster);
+const char *transfer_all_new_dbs(DbInfoArr *olddb_arr,
DbInfoArr *newdb_arr, char *old_pgdata, char *new_pgdata);
/* tablespace.c */
-void init_tablespaces(migratorContext *ctx);
+void init_tablespaces(void);
/* server.c */
-PGconn *connectToServer(migratorContext *ctx, const char *db_name,
+PGconn *connectToServer(const char *db_name,
Cluster whichCluster);
-PGresult *executeQueryOrDie(migratorContext *ctx, PGconn *conn,
+PGresult *executeQueryOrDie(PGconn *conn,
const char *fmt,...);
-void start_postmaster(migratorContext *ctx, Cluster whichCluster, bool quiet);
-void stop_postmaster(migratorContext *ctx, bool fast, bool quiet);
-uint32 get_major_server_version(migratorContext *ctx, char **verstr,
+void start_postmaster(Cluster whichCluster, bool quiet);
+void stop_postmaster(bool fast, bool quiet);
+uint32 get_major_server_version(char **verstr,
Cluster whichCluster);
-void check_for_libpq_envvars(migratorContext *ctx);
+void check_for_libpq_envvars(void);
/* util.c */
-void exit_nicely(migratorContext *ctx, bool need_cleanup);
-void *pg_malloc(migratorContext *ctx, int n);
-void pg_free(void *p);
-char *pg_strdup(migratorContext *ctx, const char *s);
-char *quote_identifier(migratorContext *ctx, const char *s);
-int get_user_info(migratorContext *ctx, char **user_name);
-void check_ok(migratorContext *ctx);
-void report_status(migratorContext *ctx, eLogType type, const char *fmt,...);
-void pg_log(migratorContext *ctx, eLogType type, char *fmt,...);
-void prep_status(migratorContext *ctx, const char *fmt,...);
-void check_ok(migratorContext *ctx);
-char *pg_strdup(migratorContext *ctx, const char *s);
-void *pg_malloc(migratorContext *ctx, int size);
+void exit_nicely(bool need_cleanup);
+char *quote_identifier(const char *s);
+int get_user_info(char **user_name);
+void check_ok(void);
+void report_status(eLogType type, const char *fmt,...);
+void pg_log(eLogType type, char *fmt,...);
+void prep_status(const char *fmt,...);
+void check_ok(void);
+char *pg_strdup(const char *s);
+void *pg_malloc(int size);
void pg_free(void *ptr);
const char *getErrorText(int errNum);
unsigned int str2uint(const char *str);
/* version.c */
-void new_9_0_populate_pg_largeobject_metadata(migratorContext *ctx,
+void new_9_0_populate_pg_largeobject_metadata(
bool check_mode, Cluster whichCluster);
/* version_old_8_3.c */
-void old_8_3_check_for_name_data_type_usage(migratorContext *ctx,
- Cluster whichCluster);
-void old_8_3_check_for_tsquery_usage(migratorContext *ctx,
- Cluster whichCluster);
-void old_8_3_rebuild_tsvector_tables(migratorContext *ctx,
- bool check_mode, Cluster whichCluster);
-void old_8_3_invalidate_hash_gin_indexes(migratorContext *ctx,
- bool check_mode, Cluster whichCluster);
-void old_8_3_invalidate_bpchar_pattern_ops_indexes(migratorContext *ctx,
- bool check_mode, Cluster whichCluster);
-char *old_8_3_create_sequence_script(migratorContext *ctx,
- Cluster whichCluster);
+void old_8_3_check_for_name_data_type_usage(Cluster whichCluster);
+void old_8_3_check_for_tsquery_usage(Cluster whichCluster);
+void old_8_3_rebuild_tsvector_tables(bool check_mode,
+ Cluster whichCluster);
+void old_8_3_invalidate_hash_gin_indexes(bool check_mode,
+ Cluster whichCluster);
+void old_8_3_invalidate_bpchar_pattern_ops_indexes(bool check_mode,
+ Cluster whichCluster);
+char *old_8_3_create_sequence_script(Cluster whichCluster);
#include "access/transam.h"
-static void transfer_single_new_db(migratorContext *ctx, pageCnvCtx *pageConverter,
+static void transfer_single_new_db(pageCnvCtx *pageConverter,
FileNameMap *maps, int size);
-static void transfer_relfile(migratorContext *ctx, pageCnvCtx *pageConverter,
+static void transfer_relfile(pageCnvCtx *pageConverter,
const char *fromfile, const char *tofile,
const char *oldnspname, const char *oldrelname,
const char *newnspname, const char *newrelname);
* physically link the databases.
*/
const char *
-transfer_all_new_dbs(migratorContext *ctx, DbInfoArr *olddb_arr,
+transfer_all_new_dbs(DbInfoArr *olddb_arr,
DbInfoArr *newdb_arr, char *old_pgdata, char *new_pgdata)
{
int dbnum;
const char *msg = NULL;
- prep_status(ctx, "Restoring user relation files\n");
+ prep_status("Restoring user relation files\n");
for (dbnum = 0; dbnum < newdb_arr->ndbs; dbnum++)
{
pageCnvCtx *pageConverter = NULL;
n_maps = 0;
- mappings = gen_db_file_maps(ctx, old_db, new_db, &n_maps, old_pgdata,
+ mappings = gen_db_file_maps(old_db, new_db, &n_maps, old_pgdata,
new_pgdata);
if (n_maps)
{
- print_maps(ctx, mappings, n_maps, new_db->db_name);
+ print_maps(mappings, n_maps, new_db->db_name);
#ifdef PAGE_CONVERSION
- msg = setupPageConverter(ctx, &pageConverter);
+ msg = setupPageConverter(&pageConverter);
#endif
- transfer_single_new_db(ctx, pageConverter, mappings, n_maps);
+ transfer_single_new_db(pageConverter, mappings, n_maps);
pg_free(mappings);
}
}
- prep_status(ctx, ""); /* in case nothing printed */
- check_ok(ctx);
+ prep_status(""); /* in case nothing printed */
+ check_ok();
return msg;
}
* relfilenodes later in the upgrade process.
*/
void
-get_pg_database_relfilenode(migratorContext *ctx, Cluster whichCluster)
+get_pg_database_relfilenode(Cluster whichCluster)
{
- PGconn *conn = connectToServer(ctx, "template1", whichCluster);
+ PGconn *conn = connectToServer("template1", whichCluster);
+ ClusterInfo *active_cluster = ACTIVE_CLUSTER(whichCluster);
PGresult *res;
int i_relfile;
- res = executeQueryOrDie(ctx, conn,
+ res = executeQueryOrDie(conn,
"SELECT c.relname, c.relfilenode "
"FROM pg_catalog.pg_class c, "
" pg_catalog.pg_namespace n "
"ORDER BY c.relname");
i_relfile = PQfnumber(res, "relfilenode");
- if (whichCluster == CLUSTER_OLD)
- ctx->old.pg_database_oid = atooid(PQgetvalue(res, 0, i_relfile));
- else
- ctx->new.pg_database_oid = atooid(PQgetvalue(res, 0, i_relfile));
+ active_cluster->pg_database_oid = atooid(PQgetvalue(res, 0, i_relfile));
PQclear(res);
PQfinish(conn);
* create links for mappings stored in "maps" array.
*/
static void
-transfer_single_new_db(migratorContext *ctx, pageCnvCtx *pageConverter,
+transfer_single_new_db(pageCnvCtx *pageConverter,
FileNameMap *maps, int size)
{
int mapnum;
/* Copying files might take some time, so give feedback. */
- snprintf(old_file, sizeof(old_file), "%s/%u", maps[mapnum].old_file, maps[mapnum].old);
- snprintf(new_file, sizeof(new_file), "%s/%u", maps[mapnum].new_file, maps[mapnum].new);
- pg_log(ctx, PG_REPORT, OVERWRITE_MESSAGE, old_file);
+ snprintf(old_file, sizeof(old_file), "%s/%u", maps[mapnum].old_file,
+ maps[mapnum].old_relfilenode);
+ snprintf(new_file, sizeof(new_file), "%s/%u", maps[mapnum].new_file,
+ maps[mapnum].new_relfilenode);
+ pg_log(PG_REPORT, OVERWRITE_MESSAGE, old_file);
/*
* Copy/link the relation file to the new cluster
*/
unlink(new_file);
- transfer_relfile(ctx, pageConverter, old_file, new_file,
+ transfer_relfile(pageConverter, old_file, new_file,
maps[mapnum].old_nspname, maps[mapnum].old_relname,
maps[mapnum].new_nspname, maps[mapnum].new_relname);
/* fsm/vm files added in PG 8.4 */
- if (GET_MAJOR_VERSION(ctx->old.major_version) >= 804)
+ if (GET_MAJOR_VERSION(old_cluster.major_version) >= 804)
{
/*
* Now copy/link any fsm and vm files, if they exist
*/
- snprintf(scandir_file_pattern, sizeof(scandir_file_pattern), "%u_", maps[mapnum].old);
- numFiles = pg_scandir(ctx, maps[mapnum].old_file, &namelist, dir_matching_filenames);
+ snprintf(scandir_file_pattern, sizeof(scandir_file_pattern), "%u_",
+ maps[mapnum].old_relfilenode);
+ numFiles = pg_scandir(maps[mapnum].old_file, &namelist, dir_matching_filenames);
while (numFiles--)
{
snprintf(old_file, sizeof(old_file), "%s/%s", maps[mapnum].old_file,
namelist[numFiles]->d_name);
snprintf(new_file, sizeof(new_file), "%s/%u%s", maps[mapnum].new_file,
- maps[mapnum].new, strchr(namelist[numFiles]->d_name, '_'));
+ maps[mapnum].new_relfilenode, strchr(namelist[numFiles]->d_name, '_'));
unlink(new_file);
- transfer_relfile(ctx, pageConverter, old_file, new_file,
+ transfer_relfile(pageConverter, old_file, new_file,
maps[mapnum].old_nspname, maps[mapnum].old_relname,
maps[mapnum].new_nspname, maps[mapnum].new_relname);
* relfilenode.3, ... 'fsm' and 'vm' files use underscores so are not
* copied.
*/
- snprintf(scandir_file_pattern, sizeof(scandir_file_pattern), "%u.", maps[mapnum].old);
- numFiles = pg_scandir(ctx, maps[mapnum].old_file, &namelist, dir_matching_filenames);
+ snprintf(scandir_file_pattern, sizeof(scandir_file_pattern), "%u.",
+ maps[mapnum].old_relfilenode);
+ numFiles = pg_scandir(maps[mapnum].old_file, &namelist, dir_matching_filenames);
while (numFiles--)
{
snprintf(old_file, sizeof(old_file), "%s/%s", maps[mapnum].old_file,
namelist[numFiles]->d_name);
snprintf(new_file, sizeof(new_file), "%s/%u%s", maps[mapnum].new_file,
- maps[mapnum].new, strchr(namelist[numFiles]->d_name, '.'));
+ maps[mapnum].new_relfilenode, strchr(namelist[numFiles]->d_name, '.'));
unlink(new_file);
- transfer_relfile(ctx, pageConverter, old_file, new_file,
+ transfer_relfile(pageConverter, old_file, new_file,
maps[mapnum].old_nspname, maps[mapnum].old_relname,
maps[mapnum].new_nspname, maps[mapnum].new_relname);
* Copy or link file from old cluster to new one.
*/
static void
-transfer_relfile(migratorContext *ctx, pageCnvCtx *pageConverter, const char *oldfile,
+transfer_relfile(pageCnvCtx *pageConverter, const char *oldfile,
const char *newfile, const char *oldnspname, const char *oldrelname,
const char *newnspname, const char *newrelname)
{
const char *msg;
- if ((ctx->transfer_mode == TRANSFER_MODE_LINK) && (pageConverter != NULL))
- pg_log(ctx, PG_FATAL, "this migration requires page-by-page conversion, "
+ if ((user_opts.transfer_mode == TRANSFER_MODE_LINK) && (pageConverter != NULL))
+ pg_log(PG_FATAL, "this migration requires page-by-page conversion, "
"you must use copy-mode instead of link-mode\n");
- if (ctx->transfer_mode == TRANSFER_MODE_COPY)
+ if (user_opts.transfer_mode == TRANSFER_MODE_COPY)
{
- pg_log(ctx, PG_INFO, "copying %s to %s\n", oldfile, newfile);
+ pg_log(PG_INFO, "copying %s to %s\n", oldfile, newfile);
- if ((msg = copyAndUpdateFile(ctx, pageConverter, oldfile, newfile, true)) != NULL)
- pg_log(ctx, PG_FATAL, "error while copying %s.%s(%s) to %s.%s(%s): %s\n",
+ if ((msg = copyAndUpdateFile(pageConverter, oldfile, newfile, true)) != NULL)
+ pg_log(PG_FATAL, "error while copying %s.%s(%s) to %s.%s(%s): %s\n",
oldnspname, oldrelname, oldfile, newnspname, newrelname, newfile, msg);
}
else
{
- pg_log(ctx, PG_INFO, "linking %s to %s\n", newfile, oldfile);
+ pg_log(PG_INFO, "linking %s to %s\n", newfile, oldfile);
- if ((msg = linkAndUpdateFile(ctx, pageConverter, oldfile, newfile)) != NULL)
- pg_log(ctx, PG_FATAL,
+ if ((msg = linkAndUpdateFile(pageConverter, oldfile, newfile)) != NULL)
+ pg_log(PG_FATAL,
"error while creating link from %s.%s(%s) to %s.%s(%s): %s\n",
oldnspname, oldrelname, oldfile, newnspname, newrelname,
newfile, msg);
#define STARTUP_WARNING_TRIES 2
-static pgpid_t get_postmaster_pid(migratorContext *ctx, const char *datadir);
-static bool test_server_conn(migratorContext *ctx, int timeout,
+static pgpid_t get_postmaster_pid(const char *datadir);
+static bool test_server_conn(int timeout,
Cluster whichCluster);
* message and calls exit_nicely() to kill the program.
*/
PGconn *
-connectToServer(migratorContext *ctx, const char *db_name,
+connectToServer(const char *db_name,
Cluster whichCluster)
{
+ ClusterInfo *active_cluster = ACTIVE_CLUSTER(whichCluster);
+ unsigned short port = active_cluster->port;
char connectString[MAXPGPATH];
- unsigned short port = (whichCluster == CLUSTER_OLD) ?
- ctx->old.port : ctx->new.port;
PGconn *conn;
snprintf(connectString, sizeof(connectString),
- "dbname = '%s' user = '%s' port = %d", db_name, ctx->user, port);
+ "dbname = '%s' user = '%s' port = %d", db_name, os_info.user, port);
conn = PQconnectdb(connectString);
if (conn == NULL || PQstatus(conn) != CONNECTION_OK)
{
- pg_log(ctx, PG_REPORT, "Connection to database failed: %s\n",
+ pg_log(PG_REPORT, "Connection to database failed: %s\n",
PQerrorMessage(conn));
if (conn)
PQfinish(conn);
- exit_nicely(ctx, true);
+ exit_nicely(true);
}
return conn;
* message and calls exit_nicely() to kill the program.
*/
PGresult *
-executeQueryOrDie(migratorContext *ctx, PGconn *conn, const char *fmt,...)
+executeQueryOrDie(PGconn *conn, const char *fmt,...)
{
static char command[8192];
va_list args;
vsnprintf(command, sizeof(command), fmt, args);
va_end(args);
- pg_log(ctx, PG_DEBUG, "executing: %s\n", command);
+ pg_log(PG_DEBUG, "executing: %s\n", command);
result = PQexec(conn, command);
status = PQresultStatus(result);
if ((status != PGRES_TUPLES_OK) && (status != PGRES_COMMAND_OK))
{
- pg_log(ctx, PG_REPORT, "DB command failed\n%s\n%s\n", command,
+ pg_log(PG_REPORT, "DB command failed\n%s\n%s\n", command,
PQerrorMessage(conn));
PQclear(result);
PQfinish(conn);
- exit_nicely(ctx, true);
+ exit_nicely(true);
return NULL; /* Never get here, but keeps compiler happy */
}
else
* from the postmaster.pid file
*/
static pgpid_t
-get_postmaster_pid(migratorContext *ctx, const char *datadir)
+get_postmaster_pid(const char *datadir)
{
FILE *pidf;
long pid;
if (fscanf(pidf, "%ld", &pid) != 1)
{
fclose(pidf);
- pg_log(ctx, PG_FATAL, "%s: invalid data in PID file \"%s\"\n",
- ctx->progname, pid_file);
+ pg_log(PG_FATAL, "%s: invalid data in PID file \"%s\"\n",
+ os_info.progname, pid_file);
}
fclose(pidf);
* is retrieved by reading the PG_VERSION file.
*/
uint32
-get_major_server_version(migratorContext *ctx, char **verstr, Cluster whichCluster)
+get_major_server_version(char **verstr, Cluster whichCluster)
{
- const char *datadir = whichCluster == CLUSTER_OLD ?
- ctx->old.pgdata : ctx->new.pgdata;
+ ClusterInfo *active_cluster = ACTIVE_CLUSTER(whichCluster);
+ const char *datadir = active_cluster->pgdata;
FILE *version_fd;
char ver_file[MAXPGPATH];
int integer_version = 0;
int fractional_version = 0;
- *verstr = pg_malloc(ctx, 64);
+ *verstr = pg_malloc(64);
snprintf(ver_file, sizeof(ver_file), "%s/PG_VERSION", datadir);
if ((version_fd = fopen(ver_file, "r")) == NULL)
if (fscanf(version_fd, "%63s", *verstr) == 0 ||
sscanf(*verstr, "%d.%d", &integer_version, &fractional_version) != 2)
{
- pg_log(ctx, PG_FATAL, "could not get version from %s\n", datadir);
+ pg_log(PG_FATAL, "could not get version from %s\n", datadir);
fclose(version_fd);
return 0;
}
void
-start_postmaster(migratorContext *ctx, Cluster whichCluster, bool quiet)
+start_postmaster(Cluster whichCluster, bool quiet)
{
+ ClusterInfo *active_cluster = ACTIVE_CLUSTER(whichCluster);
char cmd[MAXPGPATH];
const char *bindir;
const char *datadir;
unsigned short port;
- if (whichCluster == CLUSTER_OLD)
- {
- bindir = ctx->old.bindir;
- datadir = ctx->old.pgdata;
- port = ctx->old.port;
- }
- else
- {
- bindir = ctx->new.bindir;
- datadir = ctx->new.pgdata;
- port = ctx->new.port;
- }
+ bindir = active_cluster->bindir;
+ datadir = active_cluster->pgdata;
+ port = active_cluster->port;
/*
* On Win32, we can't send both pg_upgrade output and pg_ctl output to the
"start >> \"%s\" 2>&1" SYSTEMQUOTE,
bindir,
#ifndef WIN32
- ctx->logfile, datadir, port, ctx->logfile);
+ log.filename, datadir, port, log.filename);
#else
DEVNULL, datadir, port, DEVNULL);
#endif
- exec_prog(ctx, true, "%s", cmd);
+ exec_prog(true, "%s", cmd);
/* wait for the server to start properly */
- if (test_server_conn(ctx, POSTMASTER_UPTIME, whichCluster) == false)
- pg_log(ctx, PG_FATAL, " Unable to start %s postmaster with the command: %s\nPerhaps pg_hba.conf was not set to \"trust\".",
+ if (test_server_conn(POSTMASTER_UPTIME, whichCluster) == false)
+ pg_log(PG_FATAL, " Unable to start %s postmaster with the command: %s\nPerhaps pg_hba.conf was not set to \"trust\".",
CLUSTERNAME(whichCluster), cmd);
- if ((ctx->postmasterPID = get_postmaster_pid(ctx, datadir)) == 0)
- pg_log(ctx, PG_FATAL, " Unable to get postmaster pid\n");
- ctx->running_cluster = whichCluster;
+ if ((os_info.postmasterPID = get_postmaster_pid(datadir)) == 0)
+ pg_log(PG_FATAL, " Unable to get postmaster pid\n");
+ os_info.running_cluster = whichCluster;
}
void
-stop_postmaster(migratorContext *ctx, bool fast, bool quiet)
+stop_postmaster(bool fast, bool quiet)
{
char cmd[MAXPGPATH];
const char *bindir;
const char *datadir;
- if (ctx->running_cluster == CLUSTER_OLD)
+ if (os_info.running_cluster == CLUSTER_OLD)
{
- bindir = ctx->old.bindir;
- datadir = ctx->old.pgdata;
+ bindir = old_cluster.bindir;
+ datadir = old_cluster.pgdata;
}
- else if (ctx->running_cluster == CLUSTER_NEW)
+ else if (os_info.running_cluster == CLUSTER_NEW)
{
- bindir = ctx->new.bindir;
- datadir = ctx->new.pgdata;
+ bindir = new_cluster.bindir;
+ datadir = new_cluster.pgdata;
}
else
return; /* no cluster running */
"\"%s\" 2>&1" SYSTEMQUOTE,
bindir,
#ifndef WIN32
- ctx->logfile, datadir, fast ? "-m fast" : "", ctx->logfile);
+ log.filename, datadir, fast ? "-m fast" : "", log.filename);
#else
DEVNULL, datadir, fast ? "-m fast" : "", DEVNULL);
#endif
- exec_prog(ctx, fast ? false : true, "%s", cmd);
+ exec_prog(fast ? false : true, "%s", cmd);
- ctx->postmasterPID = 0;
- ctx->running_cluster = NONE;
+ os_info.postmasterPID = 0;
+ os_info.running_cluster = NONE;
}
* Returns true if the connection attempt was successfull, false otherwise.
*/
static bool
-test_server_conn(migratorContext *ctx, int timeout, Cluster whichCluster)
+test_server_conn(int timeout, Cluster whichCluster)
{
+ ClusterInfo *active_cluster = ACTIVE_CLUSTER(whichCluster);
+ unsigned short port = active_cluster->port;
PGconn *conn = NULL;
char con_opts[MAX_STRING];
int tries;
- unsigned short port = (whichCluster == CLUSTER_OLD) ?
- ctx->old.port : ctx->new.port;
bool ret = false;
snprintf(con_opts, sizeof(con_opts),
- "dbname = 'template1' user = '%s' port = %d ", ctx->user, port);
+ "dbname = 'template1' user = '%s' port = %d ", os_info.user, port);
for (tries = 0; tries < timeout; tries++)
{
}
if (tries == STARTUP_WARNING_TRIES)
- prep_status(ctx, "Trying to start %s server ",
+ prep_status("Trying to start %s server ",
CLUSTERNAME(whichCluster));
else if (tries > STARTUP_WARNING_TRIES)
- pg_log(ctx, PG_REPORT, ".");
+ pg_log(PG_REPORT, ".");
}
if (tries > STARTUP_WARNING_TRIES)
- check_ok(ctx);
+ check_ok();
return ret;
}
* If any are found, will log them and cancel.
*/
void
-check_for_libpq_envvars(migratorContext *ctx)
+check_for_libpq_envvars(void)
{
PQconninfoOption *option;
PQconninfoOption *start;
{
found = true;
- pg_log(ctx, PG_WARNING,
+ pg_log(PG_WARNING,
"libpq env var %-20s is currently set to: %s\n", option->envvar, value);
}
PQconninfoFree(start);
if (found)
- pg_log(ctx, PG_FATAL,
+ pg_log(PG_FATAL,
"libpq env vars have been found and listed above, please unset them for pg_upgrade\n");
}
#include "pg_upgrade.h"
-static void get_tablespace_paths(migratorContext *ctx);
-static void set_tablespace_directory_suffix(migratorContext *ctx,
+static void get_tablespace_paths(void);
+static void set_tablespace_directory_suffix(
Cluster whichCluster);
void
-init_tablespaces(migratorContext *ctx)
+init_tablespaces(void)
{
- get_tablespace_paths(ctx);
+ get_tablespace_paths();
- set_tablespace_directory_suffix(ctx, CLUSTER_OLD);
- set_tablespace_directory_suffix(ctx, CLUSTER_NEW);
+ set_tablespace_directory_suffix(CLUSTER_OLD);
+ set_tablespace_directory_suffix(CLUSTER_NEW);
- if (ctx->num_tablespaces > 0 &&
- strcmp(ctx->old.tablespace_suffix, ctx->new.tablespace_suffix) == 0)
- pg_log(ctx, PG_FATAL,
+ if (os_info.num_tablespaces > 0 &&
+ strcmp(old_cluster.tablespace_suffix, new_cluster.tablespace_suffix) == 0)
+ pg_log(PG_FATAL,
"Cannot migrate to/from the same system catalog version when\n"
"using tablespaces.\n");
}
* paths. Its the caller's responsibility to free the array.
*/
static void
-get_tablespace_paths(migratorContext *ctx)
+get_tablespace_paths(void)
{
- PGconn *conn = connectToServer(ctx, "template1", CLUSTER_OLD);
+ PGconn *conn = connectToServer("template1", CLUSTER_OLD);
PGresult *res;
int tblnum;
int i_spclocation;
- res = executeQueryOrDie(ctx, conn,
+ res = executeQueryOrDie(conn,
"SELECT spclocation "
"FROM pg_catalog.pg_tablespace "
"WHERE spcname != 'pg_default' AND "
" spcname != 'pg_global'");
- if ((ctx->num_tablespaces = PQntuples(res)) != 0)
- ctx->tablespaces = (char **) pg_malloc(ctx,
- ctx->num_tablespaces * sizeof(char *));
+ if ((os_info.num_tablespaces = PQntuples(res)) != 0)
+ os_info.tablespaces = (char **) pg_malloc(
+ os_info.num_tablespaces * sizeof(char *));
else
- ctx->tablespaces = NULL;
+ os_info.tablespaces = NULL;
i_spclocation = PQfnumber(res, "spclocation");
- for (tblnum = 0; tblnum < ctx->num_tablespaces; tblnum++)
- ctx->tablespaces[tblnum] = pg_strdup(ctx,
+ for (tblnum = 0; tblnum < os_info.num_tablespaces; tblnum++)
+ os_info.tablespaces[tblnum] = pg_strdup(
PQgetvalue(res, tblnum, i_spclocation));
PQclear(res);
static void
-set_tablespace_directory_suffix(migratorContext *ctx, Cluster whichCluster)
+set_tablespace_directory_suffix(Cluster whichCluster)
{
- ClusterInfo *cluster = (whichCluster == CLUSTER_OLD) ? &ctx->old : &ctx->new;
+ ClusterInfo *active_cluster = ACTIVE_CLUSTER(whichCluster);
- if (GET_MAJOR_VERSION(cluster->major_version) <= 804)
- cluster->tablespace_suffix = pg_strdup(ctx, "");
+ if (GET_MAJOR_VERSION(active_cluster->major_version) <= 804)
+ active_cluster->tablespace_suffix = pg_strdup("");
else
{
/* This cluster has a version-specific subdirectory */
- cluster->tablespace_suffix = pg_malloc(ctx, 4 + strlen(cluster->major_version_str) +
- 10 /* OIDCHARS */ + 1);
+ active_cluster->tablespace_suffix = pg_malloc(4 +
+ strlen(active_cluster->major_version_str) +
+ 10 /* OIDCHARS */ + 1);
/* The leading slash is needed to start a new directory. */
- sprintf(cluster->tablespace_suffix, "/PG_%s_%d", cluster->major_version_str,
- cluster->controldata.cat_ver);
+ sprintf(active_cluster->tablespace_suffix, "/PG_%s_%d", active_cluster->major_version_str,
+ active_cluster->controldata.cat_ver);
}
}
#include <signal.h>
+Log log;
+
/*
* report_status()
*
* Displays the result of an operation (ok, failed, error message,...)
*/
void
-report_status(migratorContext *ctx, eLogType type, const char *fmt,...)
+report_status(eLogType type, const char *fmt,...)
{
va_list args;
char message[MAX_STRING];
vsnprintf(message, sizeof(message), fmt, args);
va_end(args);
- pg_log(ctx, type, "%s\n", message);
+ pg_log(type, "%s\n", message);
}
/*
- * prep_status(&ctx, )
+ * prep_status
*
* Displays a message that describes an operation we are about to begin.
* We pad the message out to MESSAGE_WIDTH characters so that all of the "ok" and
* "failed" indicators line up nicely.
*
* A typical sequence would look like this:
- * prep_status(&ctx, "about to flarb the next %d files", fileCount );
+ * prep_status("about to flarb the next %d files", fileCount );
*
* if(( message = flarbFiles(fileCount)) == NULL)
- * report_status(ctx, PG_REPORT, "ok" );
+ * report_status(PG_REPORT, "ok" );
* else
- * pg_log(ctx, PG_FATAL, "failed - %s", message );
+ * pg_log(PG_FATAL, "failed - %s", message );
*/
void
-prep_status(migratorContext *ctx, const char *fmt,...)
+prep_status(const char *fmt,...)
{
va_list args;
char message[MAX_STRING];
va_end(args);
if (strlen(message) > 0 && message[strlen(message) - 1] == '\n')
- pg_log(ctx, PG_REPORT, "%s", message);
+ pg_log(PG_REPORT, "%s", message);
else
- pg_log(ctx, PG_REPORT, "%-" MESSAGE_WIDTH "s", message);
+ pg_log(PG_REPORT, "%-" MESSAGE_WIDTH "s", message);
}
void
-pg_log(migratorContext *ctx, eLogType type, char *fmt,...)
+pg_log(eLogType type, char *fmt,...)
{
va_list args;
char message[MAX_STRING];
vsnprintf(message, sizeof(message), fmt, args);
va_end(args);
- if (ctx->log_fd != NULL)
+ if (log.fd != NULL)
{
- fwrite(message, strlen(message), 1, ctx->log_fd);
+ fwrite(message, strlen(message), 1, log.fd);
/* if we are using OVERWRITE_MESSAGE, add newline */
if (strchr(message, '\r') != NULL)
- fwrite("\n", 1, 1, ctx->log_fd);
- fflush(ctx->log_fd);
+ fwrite("\n", 1, 1, log.fd);
+ fflush(log.fd);
}
switch (type)
{
case PG_INFO:
- if (ctx->verbose)
+ if (log.verbose)
printf("%s", _(message));
break;
case PG_FATAL:
printf("%s", "\n");
printf("%s", _(message));
- exit_nicely(ctx, true);
+ exit_nicely(true);
break;
case PG_DEBUG:
- if (ctx->debug)
- fprintf(ctx->debug_fd, "%s\n", _(message));
+ if (log.debug)
+ fprintf(log.debug_fd, "%s\n", _(message));
break;
default:
void
-check_ok(migratorContext *ctx)
+check_ok(void)
{
/* all seems well */
- report_status(ctx, PG_REPORT, "ok");
+ report_status(PG_REPORT, "ok");
fflush(stdout);
}
* memory leakage is not a big deal in this program.
*/
char *
-quote_identifier(migratorContext *ctx, const char *s)
+quote_identifier(const char *s)
{
- char *result = pg_malloc(ctx, strlen(s) * 2 + 3);
+ char *result = pg_malloc(strlen(s) * 2 + 3);
char *r = result;
*r++ = '"';
* (copied from initdb.c) find the current user
*/
int
-get_user_info(migratorContext *ctx, char **user_name)
+get_user_info(char **user_name)
{
int user_id;
user_id = 1;
#endif
- *user_name = pg_strdup(ctx, pw->pw_name);
+ *user_name = pg_strdup(pw->pw_name);
return user_id;
}
void
-exit_nicely(migratorContext *ctx, bool need_cleanup)
+exit_nicely(bool need_cleanup)
{
- stop_postmaster(ctx, true, true);
+ stop_postmaster(true, true);
- pg_free(ctx->logfile);
+ pg_free(log.filename);
- if (ctx->log_fd)
- fclose(ctx->log_fd);
+ if (log.fd)
+ fclose(log.fd);
- if (ctx->debug_fd)
- fclose(ctx->debug_fd);
+ if (log.debug_fd)
+ fclose(log.debug_fd);
/* terminate any running instance of postmaster */
- if (ctx->postmasterPID != 0)
- kill(ctx->postmasterPID, SIGTERM);
+ if (os_info.postmasterPID != 0)
+ kill(os_info.postmasterPID, SIGTERM);
if (need_cleanup)
{
void *
-pg_malloc(migratorContext *ctx, int n)
+pg_malloc(int n)
{
void *p = malloc(n);
if (p == NULL)
- pg_log(ctx, PG_FATAL, "%s: out of memory\n", ctx->progname);
+ pg_log(PG_FATAL, "%s: out of memory\n", os_info.progname);
return p;
}
char *
-pg_strdup(migratorContext *ctx, const char *s)
+pg_strdup(const char *s)
{
char *result = strdup(s);
if (result == NULL)
- pg_log(ctx, PG_FATAL, "%s: out of memory\n", ctx->progname);
+ pg_log(PG_FATAL, "%s: out of memory\n", os_info.progname);
return result;
}
* 9.0 has a new pg_largeobject permission table
*/
void
-new_9_0_populate_pg_largeobject_metadata(migratorContext *ctx, bool check_mode,
+new_9_0_populate_pg_largeobject_metadata(bool check_mode,
Cluster whichCluster)
{
- ClusterInfo *active_cluster = (whichCluster == CLUSTER_OLD) ?
- &ctx->old : &ctx->new;
+ ClusterInfo *active_cluster = ACTIVE_CLUSTER(whichCluster);
int dbnum;
FILE *script = NULL;
bool found = false;
char output_path[MAXPGPATH];
- prep_status(ctx, "Checking for large objects");
+ prep_status("Checking for large objects");
snprintf(output_path, sizeof(output_path), "%s/pg_largeobject.sql",
- ctx->cwd);
+ os_info.cwd);
for (dbnum = 0; dbnum < active_cluster->dbarr.ndbs; dbnum++)
{
PGresult *res;
int i_count;
DbInfo *active_db = &active_cluster->dbarr.dbs[dbnum];
- PGconn *conn = connectToServer(ctx, active_db->db_name, whichCluster);
+ PGconn *conn = connectToServer(active_db->db_name, whichCluster);
/* find if there are any large objects */
- res = executeQueryOrDie(ctx, conn,
+ res = executeQueryOrDie(conn,
"SELECT count(*) "
"FROM pg_catalog.pg_largeobject ");
if (!check_mode)
{
if (script == NULL && (script = fopen(output_path, "w")) == NULL)
- pg_log(ctx, PG_FATAL, "Could not create necessary file: %s\n", output_path);
+ pg_log(PG_FATAL, "Could not create necessary file: %s\n", output_path);
fprintf(script, "\\connect %s\n",
- quote_identifier(ctx, active_db->db_name));
+ quote_identifier(active_db->db_name));
fprintf(script,
"SELECT pg_catalog.lo_create(t.loid)\n"
"FROM (SELECT DISTINCT loid FROM pg_catalog.pg_largeobject) AS t;\n");
{
if (!check_mode)
fclose(script);
- report_status(ctx, PG_WARNING, "warning");
+ report_status(PG_WARNING, "warning");
if (check_mode)
- pg_log(ctx, PG_WARNING, "\n"
+ pg_log(PG_WARNING, "\n"
"| Your installation contains large objects.\n"
"| The new database has an additional large object\n"
"| permission table. After migration, you will be\n"
"| given a command to populate the pg_largeobject\n"
"| permission table with default permissions.\n\n");
else
- pg_log(ctx, PG_WARNING, "\n"
+ pg_log(PG_WARNING, "\n"
"| Your installation contains large objects.\n"
"| The new database has an additional large object\n"
"| permission table so default permissions must be\n"
output_path);
}
else
- check_ok(ctx);
+ check_ok();
}
* checks tables and indexes.
*/
void
-old_8_3_check_for_name_data_type_usage(migratorContext *ctx, Cluster whichCluster)
+old_8_3_check_for_name_data_type_usage(Cluster whichCluster)
{
- ClusterInfo *active_cluster = (whichCluster == CLUSTER_OLD) ?
- &ctx->old : &ctx->new;
+ ClusterInfo *active_cluster = ACTIVE_CLUSTER(whichCluster);
int dbnum;
FILE *script = NULL;
bool found = false;
char output_path[MAXPGPATH];
- prep_status(ctx, "Checking for invalid 'name' user columns");
+ prep_status("Checking for invalid 'name' user columns");
snprintf(output_path, sizeof(output_path), "%s/tables_using_name.txt",
- ctx->cwd);
+ os_info.cwd);
for (dbnum = 0; dbnum < active_cluster->dbarr.ndbs; dbnum++)
{
i_relname,
i_attname;
DbInfo *active_db = &active_cluster->dbarr.dbs[dbnum];
- PGconn *conn = connectToServer(ctx, active_db->db_name, whichCluster);
+ PGconn *conn = connectToServer(active_db->db_name, whichCluster);
/*
* With a smaller alignment in 8.4, 'name' cannot be used in a
* that condition with enough analysis, but it seems not worth the
* trouble.)
*/
- res = executeQueryOrDie(ctx, conn,
+ res = executeQueryOrDie(conn,
"SELECT n.nspname, c.relname, a.attname "
"FROM pg_catalog.pg_class c, "
" pg_catalog.pg_namespace n, "
{
found = true;
if (script == NULL && (script = fopen(output_path, "w")) == NULL)
- pg_log(ctx, PG_FATAL, "Could not create necessary file: %s\n", output_path);
+ pg_log(PG_FATAL, "Could not create necessary file: %s\n", output_path);
if (!db_used)
{
fprintf(script, "Database: %s\n", active_db->db_name);
if (found)
{
fclose(script);
- pg_log(ctx, PG_REPORT, "fatal\n");
- pg_log(ctx, PG_FATAL,
+ pg_log(PG_REPORT, "fatal\n");
+ pg_log(PG_FATAL,
"| Your installation contains the \"name\" data type in\n"
"| user tables. This data type changed its internal\n"
"| alignment between your old and new clusters so this\n"
"| \t%s\n\n", output_path);
}
else
- check_ok(ctx);
+ check_ok();
}
* so migration of such fields is impossible.
*/
void
-old_8_3_check_for_tsquery_usage(migratorContext *ctx, Cluster whichCluster)
+old_8_3_check_for_tsquery_usage(Cluster whichCluster)
{
- ClusterInfo *active_cluster = (whichCluster == CLUSTER_OLD) ?
- &ctx->old : &ctx->new;
+ ClusterInfo *active_cluster = ACTIVE_CLUSTER(whichCluster);
int dbnum;
FILE *script = NULL;
bool found = false;
char output_path[MAXPGPATH];
- prep_status(ctx, "Checking for tsquery user columns");
+ prep_status("Checking for tsquery user columns");
snprintf(output_path, sizeof(output_path), "%s/tables_using_tsquery.txt",
- ctx->cwd);
+ os_info.cwd);
for (dbnum = 0; dbnum < active_cluster->dbarr.ndbs; dbnum++)
{
i_relname,
i_attname;
DbInfo *active_db = &active_cluster->dbarr.dbs[dbnum];
- PGconn *conn = connectToServer(ctx, active_db->db_name, whichCluster);
+ PGconn *conn = connectToServer(active_db->db_name, whichCluster);
/* Find any user-defined tsquery columns */
- res = executeQueryOrDie(ctx, conn,
+ res = executeQueryOrDie(conn,
"SELECT n.nspname, c.relname, a.attname "
"FROM pg_catalog.pg_class c, "
" pg_catalog.pg_namespace n, "
{
found = true;
if (script == NULL && (script = fopen(output_path, "w")) == NULL)
- pg_log(ctx, PG_FATAL, "Could not create necessary file: %s\n", output_path);
+ pg_log(PG_FATAL, "Could not create necessary file: %s\n", output_path);
if (!db_used)
{
fprintf(script, "Database: %s\n", active_db->db_name);
if (found)
{
fclose(script);
- pg_log(ctx, PG_REPORT, "fatal\n");
- pg_log(ctx, PG_FATAL,
+ pg_log(PG_REPORT, "fatal\n");
+ pg_log(PG_FATAL,
"| Your installation contains the \"tsquery\" data type.\n"
"| This data type added a new internal field between\n"
"| your old and new clusters so this cluster cannot\n"
"| \t%s\n\n", output_path);
}
else
- check_ok(ctx);
+ check_ok();
}
* 'c' 'bb' 'aaa' -- 8.3
*/
void
-old_8_3_rebuild_tsvector_tables(migratorContext *ctx, bool check_mode,
+old_8_3_rebuild_tsvector_tables(bool check_mode,
Cluster whichCluster)
{
- ClusterInfo *active_cluster = (whichCluster == CLUSTER_OLD) ?
- &ctx->old : &ctx->new;
+ ClusterInfo *active_cluster = ACTIVE_CLUSTER(whichCluster);
int dbnum;
FILE *script = NULL;
bool found = false;
char output_path[MAXPGPATH];
- prep_status(ctx, "Checking for tsvector user columns");
+ prep_status("Checking for tsvector user columns");
snprintf(output_path, sizeof(output_path), "%s/rebuild_tsvector_tables.sql",
- ctx->cwd);
+ os_info.cwd);
for (dbnum = 0; dbnum < active_cluster->dbarr.ndbs; dbnum++)
{
i_relname,
i_attname;
DbInfo *active_db = &active_cluster->dbarr.dbs[dbnum];
- PGconn *conn = connectToServer(ctx, active_db->db_name, whichCluster);
+ PGconn *conn = connectToServer(active_db->db_name, whichCluster);
/* Find any user-defined tsvector columns */
- res = executeQueryOrDie(ctx, conn,
+ res = executeQueryOrDie(conn,
"SELECT n.nspname, c.relname, a.attname "
"FROM pg_catalog.pg_class c, "
" pg_catalog.pg_namespace n, "
if (!check_mode)
{
if (script == NULL && (script = fopen(output_path, "w")) == NULL)
- pg_log(ctx, PG_FATAL, "Could not create necessary file: %s\n", output_path);
+ pg_log(PG_FATAL, "Could not create necessary file: %s\n", output_path);
if (!db_used)
{
fprintf(script, "\\connect %s\n\n",
- quote_identifier(ctx, active_db->db_name));
+ quote_identifier(active_db->db_name));
db_used = true;
}
if (strlen(old_nspname) != 0 || strlen(old_relname) != 0)
fprintf(script, ";\n\n");
fprintf(script, "ALTER TABLE %s.%s\n",
- quote_identifier(ctx, PQgetvalue(res, rowno, i_nspname)),
- quote_identifier(ctx, PQgetvalue(res, rowno, i_relname)));
+ quote_identifier(PQgetvalue(res, rowno, i_nspname)),
+ quote_identifier(PQgetvalue(res, rowno, i_relname)));
}
else
fprintf(script, ",\n");
fprintf(script, "ALTER COLUMN %s "
/* This could have been a custom conversion function call. */
"TYPE pg_catalog.tsvector USING %s::pg_catalog.text::pg_catalog.tsvector",
- quote_identifier(ctx, PQgetvalue(res, rowno, i_attname)),
- quote_identifier(ctx, PQgetvalue(res, rowno, i_attname)));
+ quote_identifier(PQgetvalue(res, rowno, i_attname)),
+ quote_identifier(PQgetvalue(res, rowno, i_attname)));
}
}
if (strlen(old_nspname) != 0 || strlen(old_relname) != 0)
{
if (!check_mode)
fclose(script);
- report_status(ctx, PG_WARNING, "warning");
+ report_status(PG_WARNING, "warning");
if (check_mode)
- pg_log(ctx, PG_WARNING, "\n"
+ pg_log(PG_WARNING, "\n"
"| Your installation contains tsvector columns.\n"
"| The tsvector internal storage format changed\n"
"| between your old and new clusters so the tables\n"
"| must be rebuilt. After migration, you will be\n"
"| given instructions.\n\n");
else
- pg_log(ctx, PG_WARNING, "\n"
+ pg_log(PG_WARNING, "\n"
"| Your installation contains tsvector columns.\n"
"| The tsvector internal storage format changed\n"
"| between your old and new clusters so the tables\n"
output_path);
}
else
- check_ok(ctx);
+ check_ok();
}
* Hash, Gin, and GiST index binary format has changes from 8.3->8.4
*/
void
-old_8_3_invalidate_hash_gin_indexes(migratorContext *ctx, bool check_mode,
+old_8_3_invalidate_hash_gin_indexes(bool check_mode,
Cluster whichCluster)
{
- ClusterInfo *active_cluster = (whichCluster == CLUSTER_OLD) ?
- &ctx->old : &ctx->new;
+ ClusterInfo *active_cluster = ACTIVE_CLUSTER(whichCluster);
int dbnum;
FILE *script = NULL;
bool found = false;
char output_path[MAXPGPATH];
- prep_status(ctx, "Checking for hash and gin indexes");
+ prep_status("Checking for hash and gin indexes");
snprintf(output_path, sizeof(output_path), "%s/reindex_hash_and_gin.sql",
- ctx->cwd);
+ os_info.cwd);
for (dbnum = 0; dbnum < active_cluster->dbarr.ndbs; dbnum++)
{
int i_nspname,
i_relname;
DbInfo *active_db = &active_cluster->dbarr.dbs[dbnum];
- PGconn *conn = connectToServer(ctx, active_db->db_name, whichCluster);
+ PGconn *conn = connectToServer(active_db->db_name, whichCluster);
/* find hash and gin indexes */
- res = executeQueryOrDie(ctx, conn,
+ res = executeQueryOrDie(conn,
"SELECT n.nspname, c.relname "
"FROM pg_catalog.pg_class c, "
" pg_catalog.pg_index i, "
if (!check_mode)
{
if (script == NULL && (script = fopen(output_path, "w")) == NULL)
- pg_log(ctx, PG_FATAL, "Could not create necessary file: %s\n", output_path);
+ pg_log(PG_FATAL, "Could not create necessary file: %s\n", output_path);
if (!db_used)
{
fprintf(script, "\\connect %s\n",
- quote_identifier(ctx, active_db->db_name));
+ quote_identifier(active_db->db_name));
db_used = true;
}
fprintf(script, "REINDEX INDEX %s.%s;\n",
- quote_identifier(ctx, PQgetvalue(res, rowno, i_nspname)),
- quote_identifier(ctx, PQgetvalue(res, rowno, i_relname)));
+ quote_identifier(PQgetvalue(res, rowno, i_nspname)),
+ quote_identifier(PQgetvalue(res, rowno, i_relname)));
}
}
if (!check_mode && found)
/* mark hash and gin indexes as invalid */
- PQclear(executeQueryOrDie(ctx, conn,
+ PQclear(executeQueryOrDie(conn,
"UPDATE pg_catalog.pg_index i "
"SET indisvalid = false "
"FROM pg_catalog.pg_class c, "
{
if (!check_mode)
fclose(script);
- report_status(ctx, PG_WARNING, "warning");
+ report_status(PG_WARNING, "warning");
if (check_mode)
- pg_log(ctx, PG_WARNING, "\n"
+ pg_log(PG_WARNING, "\n"
"| Your installation contains hash and/or gin\n"
"| indexes. These indexes have different\n"
"| internal formats between your old and new\n"
"| REINDEX command. After migration, you will\n"
"| be given REINDEX instructions.\n\n");
else
- pg_log(ctx, PG_WARNING, "\n"
+ pg_log(PG_WARNING, "\n"
"| Your installation contains hash and/or gin\n"
"| indexes. These indexes have different internal\n"
"| formats between your old and new clusters so\n"
output_path);
}
else
- check_ok(ctx);
+ check_ok();
}
* 8.4 bpchar_pattern_ops no longer sorts based on trailing spaces
*/
void
-old_8_3_invalidate_bpchar_pattern_ops_indexes(migratorContext *ctx, bool check_mode,
+old_8_3_invalidate_bpchar_pattern_ops_indexes(bool check_mode,
Cluster whichCluster)
{
- ClusterInfo *active_cluster = (whichCluster == CLUSTER_OLD) ?
- &ctx->old : &ctx->new;
+ ClusterInfo *active_cluster = ACTIVE_CLUSTER(whichCluster);
int dbnum;
FILE *script = NULL;
bool found = false;
char output_path[MAXPGPATH];
- prep_status(ctx, "Checking for bpchar_pattern_ops indexes");
+ prep_status("Checking for bpchar_pattern_ops indexes");
snprintf(output_path, sizeof(output_path), "%s/reindex_bpchar_ops.sql",
- ctx->cwd);
+ os_info.cwd);
for (dbnum = 0; dbnum < active_cluster->dbarr.ndbs; dbnum++)
{
int i_nspname,
i_relname;
DbInfo *active_db = &active_cluster->dbarr.dbs[dbnum];
- PGconn *conn = connectToServer(ctx, active_db->db_name, whichCluster);
+ PGconn *conn = connectToServer(active_db->db_name, whichCluster);
/* find bpchar_pattern_ops indexes */
* Do only non-hash, non-gin indexees; we already invalidated them
* above; no need to reindex twice
*/
- res = executeQueryOrDie(ctx, conn,
+ res = executeQueryOrDie(conn,
"SELECT n.nspname, c.relname "
"FROM pg_catalog.pg_index i, "
" pg_catalog.pg_class c, "
if (!check_mode)
{
if (script == NULL && (script = fopen(output_path, "w")) == NULL)
- pg_log(ctx, PG_FATAL, "Could not create necessary file: %s\n", output_path);
+ pg_log(PG_FATAL, "Could not create necessary file: %s\n", output_path);
if (!db_used)
{
fprintf(script, "\\connect %s\n",
- quote_identifier(ctx, active_db->db_name));
+ quote_identifier(active_db->db_name));
db_used = true;
}
fprintf(script, "REINDEX INDEX %s.%s;\n",
- quote_identifier(ctx, PQgetvalue(res, rowno, i_nspname)),
- quote_identifier(ctx, PQgetvalue(res, rowno, i_relname)));
+ quote_identifier(PQgetvalue(res, rowno, i_nspname)),
+ quote_identifier(PQgetvalue(res, rowno, i_relname)));
}
}
if (!check_mode && found)
/* mark bpchar_pattern_ops indexes as invalid */
- PQclear(executeQueryOrDie(ctx, conn,
+ PQclear(executeQueryOrDie(conn,
"UPDATE pg_catalog.pg_index i "
"SET indisvalid = false "
"FROM pg_catalog.pg_class c, "
{
if (!check_mode)
fclose(script);
- report_status(ctx, PG_WARNING, "warning");
+ report_status(PG_WARNING, "warning");
if (check_mode)
- pg_log(ctx, PG_WARNING, "\n"
+ pg_log(PG_WARNING, "\n"
"| Your installation contains indexes using\n"
"| \"bpchar_pattern_ops\". These indexes have\n"
"| different internal formats between your old and\n"
"| REINDEX command. After migration, you will be\n"
"| given REINDEX instructions.\n\n");
else
- pg_log(ctx, PG_WARNING, "\n"
+ pg_log(PG_WARNING, "\n"
"| Your installation contains indexes using\n"
"| \"bpchar_pattern_ops\". These indexes have\n"
"| different internal formats between your old and\n"
output_path);
}
else
- check_ok(ctx);
+ check_ok();
}
* server, even in link mode.
*/
char *
-old_8_3_create_sequence_script(migratorContext *ctx, Cluster whichCluster)
+old_8_3_create_sequence_script(Cluster whichCluster)
{
- ClusterInfo *active_cluster = (whichCluster == CLUSTER_OLD) ?
- &ctx->old : &ctx->new;
+ ClusterInfo *active_cluster = ACTIVE_CLUSTER(whichCluster);
int dbnum;
FILE *script = NULL;
bool found = false;
- char *output_path = pg_malloc(ctx, MAXPGPATH);
+ char *output_path = pg_malloc(MAXPGPATH);
- snprintf(output_path, MAXPGPATH, "%s/adjust_sequences.sql", ctx->cwd);
+ snprintf(output_path, MAXPGPATH, "%s/adjust_sequences.sql", os_info.cwd);
- prep_status(ctx, "Creating script to adjust sequences");
+ prep_status("Creating script to adjust sequences");
for (dbnum = 0; dbnum < active_cluster->dbarr.ndbs; dbnum++)
{
int i_nspname,
i_relname;
DbInfo *active_db = &active_cluster->dbarr.dbs[dbnum];
- PGconn *conn = connectToServer(ctx, active_db->db_name, whichCluster);
+ PGconn *conn = connectToServer(active_db->db_name, whichCluster);
/* Find any sequences */
- res = executeQueryOrDie(ctx, conn,
+ res = executeQueryOrDie(conn,
"SELECT n.nspname, c.relname "
"FROM pg_catalog.pg_class c, "
" pg_catalog.pg_namespace n "
found = true;
if (script == NULL && (script = fopen(output_path, "w")) == NULL)
- pg_log(ctx, PG_FATAL, "Could not create necessary file: %s\n", output_path);
+ pg_log(PG_FATAL, "Could not create necessary file: %s\n", output_path);
if (!db_used)
{
fprintf(script, "\\connect %s\n\n",
- quote_identifier(ctx, active_db->db_name));
+ quote_identifier(active_db->db_name));
db_used = true;
}
/* Find the desired sequence */
- seq_res = executeQueryOrDie(ctx, conn,
+ seq_res = executeQueryOrDie(conn,
"SELECT s.last_value, s.is_called "
"FROM %s.%s s",
- quote_identifier(ctx, nspname),
- quote_identifier(ctx, relname));
+ quote_identifier(nspname),
+ quote_identifier(relname));
assert(PQntuples(seq_res) == 1);
i_last_value = PQfnumber(seq_res, "last_value");
i_is_called = PQfnumber(seq_res, "is_called");
fprintf(script, "SELECT setval('%s.%s', %s, '%s');\n",
- quote_identifier(ctx, nspname), quote_identifier(ctx, relname),
+ quote_identifier(nspname), quote_identifier(relname),
PQgetvalue(seq_res, 0, i_last_value), PQgetvalue(seq_res, 0, i_is_called));
PQclear(seq_res);
}
if (found)
fclose(script);
- check_ok(ctx);
+ check_ok();
if (found)
return output_path;
projects / postgresql.git / commitdiff