Define PG_TBLSPC_DIR for path pg_tblspc/ in data folder

Similarly to 2065ddf5e34c, this introduces a define for "pg_tblspc".
This makes the style more consistent with the existing PG_STAT_TMP_DIR,
for example.

There is a difference with the other cases with the introduction of
PG_TBLSPC_DIR_SLASH, required in two places for recovery and backups.

Author: Bertrand Drouvot
Reviewed-by: Ashutosh Bapat, Álvaro Herrera, Yugo Nagata, Michael
Paquier
Discussion: https://postgr.es/m/ZryVvjqS9SnV1GPP@ip-10-97-1-34.eu-west-3.compute.internal

diff --git a/src/backend/access/transam/xlog.c b/src/backend/access/transam/xlog.c
index ee0fb0e28f8ff7ca70d611e7c6b7c204ca87dc88..4e06d86196fb3b6533fff1c8fe6184ab1186419f 100644 (file)
--- a/src/backend/access/transam/xlog.c
+++ b/src/backend/access/transam/xlog.c
@@ -8944,10 +8944,10 @@ do_pg_backup_start(const char *backupidstr, bool fast, List **tablespaces,
                datadirpathlen = strlen(DataDir);
 
                /* Collect information about all tablespaces */
-               tblspcdir = AllocateDir("pg_tblspc");
-               while ((de = ReadDir(tblspcdir, "pg_tblspc")) != NULL)
+               tblspcdir = AllocateDir(PG_TBLSPC_DIR);
+               while ((de = ReadDir(tblspcdir, PG_TBLSPC_DIR)) != NULL)
                {
-                       char            fullpath[MAXPGPATH + 10];
+                       char            fullpath[MAXPGPATH + sizeof(PG_TBLSPC_DIR)];
                        char            linkpath[MAXPGPATH];
                        char       *relpath = NULL;
                        char       *s;
@@ -8970,7 +8970,7 @@ do_pg_backup_start(const char *backupidstr, bool fast, List **tablespaces,
                        if (*badp != '\0' || errno == EINVAL || errno == ERANGE)
                                continue;
 
-                       snprintf(fullpath, sizeof(fullpath), "pg_tblspc/%s", de->d_name);
+                       snprintf(fullpath, sizeof(fullpath), "%s/%s", PG_TBLSPC_DIR, de->d_name);
 
                        de_type = get_dirent_type(fullpath, de, false, ERROR);
 
@@ -9031,8 +9031,8 @@ do_pg_backup_start(const char *backupidstr, bool fast, List **tablespaces,
                                 * In this case, we store a relative path rather than an
                                 * absolute path into the tablespaceinfo.
                                 */
-                               snprintf(linkpath, sizeof(linkpath), "pg_tblspc/%s",
-                                                de->d_name);
+                               snprintf(linkpath, sizeof(linkpath), "%s/%s",
+                                                PG_TBLSPC_DIR, de->d_name);
                                relpath = pstrdup(linkpath);
                        }
                        else

diff --git a/src/backend/access/transam/xlogrecovery.c b/src/backend/access/transam/xlogrecovery.c
index ad817fbca670db7b1fd53945f04df7ddcaaec076..178491f6f50b6c31e27c28f7676b84580f7508fa 100644 (file)
--- a/src/backend/access/transam/xlogrecovery.c
+++ b/src/backend/access/transam/xlogrecovery.c
@@ -677,7 +677,7 @@ InitWalRecovery(ControlFileData *ControlFile, bool *wasShutdown_ptr,
                                tablespaceinfo *ti = lfirst(lc);
                                char       *linkloc;
 
-                               linkloc = psprintf("pg_tblspc/%u", ti->oid);
+                               linkloc = psprintf("%s/%u", PG_TBLSPC_DIR, ti->oid);
 
                                /*
                                 * Remove the existing symlink if any and Create the symlink
@@ -2157,23 +2157,24 @@ CheckTablespaceDirectory(void)
        DIR                *dir;
        struct dirent *de;
 
-       dir = AllocateDir("pg_tblspc");
-       while ((de = ReadDir(dir, "pg_tblspc")) != NULL)
+       dir = AllocateDir(PG_TBLSPC_DIR);
+       while ((de = ReadDir(dir, PG_TBLSPC_DIR)) != NULL)
        {
-               char            path[MAXPGPATH + 10];
+               char            path[MAXPGPATH + sizeof(PG_TBLSPC_DIR)];
 
                /* Skip entries of non-oid names */
                if (strspn(de->d_name, "0123456789") != strlen(de->d_name))
                        continue;
 
-               snprintf(path, sizeof(path), "pg_tblspc/%s", de->d_name);
+               snprintf(path, sizeof(path), "%s/%s", PG_TBLSPC_DIR, de->d_name);
 
                if (get_dirent_type(path, de, false, ERROR) != PGFILETYPE_LNK)
                        ereport(allow_in_place_tablespaces ? WARNING : PANIC,
                                        (errcode(ERRCODE_DATA_CORRUPTED),
                                         errmsg("unexpected directory entry \"%s\" found in %s",
-                                                       de->d_name, "pg_tblspc/"),
-                                        errdetail("All directory entries in pg_tblspc/ should be symbolic links."),
+                                                       de->d_name, PG_TBLSPC_DIR),
+                                        errdetail("All directory entries in %s/ should be symbolic links.",
+                                                          PG_TBLSPC_DIR),
                                         errhint("Remove those directories, or set \"allow_in_place_tablespaces\" to ON transiently to let recovery complete.")));
        }
 }

diff --git a/src/backend/backup/backup_manifest.c b/src/backend/backup/backup_manifest.c
index 4357cfa31de6631b7eb552174e666f5ade663234..a2e2f86332a580bff43b7e4fb9891ef54a11e911 100644 (file)
--- a/src/backend/backup/backup_manifest.c
+++ b/src/backend/backup/backup_manifest.c
@@ -16,6 +16,7 @@
 #include "access/xlog.h"
 #include "backup/backup_manifest.h"
 #include "backup/basebackup_sink.h"
+#include "common/relpath.h"
 #include "mb/pg_wchar.h"
 #include "utils/builtins.h"
 #include "utils/json.h"
@@ -117,7 +118,7 @@ AddFileToBackupManifest(backup_manifest_info *manifest, Oid spcoid,
         */
        if (OidIsValid(spcoid))
        {
-               snprintf(pathbuf, sizeof(pathbuf), "pg_tblspc/%u/%s", spcoid,
+               snprintf(pathbuf, sizeof(pathbuf), "%s/%u/%s", PG_TBLSPC_DIR, spcoid,
                                 pathname);
                pathname = pathbuf;
        }

diff --git a/src/backend/backup/basebackup.c b/src/backend/backup/basebackup.c
index de16afac749e082272525cdb4c462f22154fea8a..14e5ba72e97a4e70479f3b157c5c5e343f1b1780 100644 (file)
--- a/src/backend/backup/basebackup.c
+++ b/src/backend/backup/basebackup.c
@@ -1488,7 +1488,7 @@ sendDir(bbsink *sink, const char *path, int basepathlen, bool sizeonly,
                                if (OidIsValid(spcoid))
                                {
                                        relspcoid = spcoid;
-                                       lookup_path = psprintf("pg_tblspc/%u/%s", spcoid,
+                                       lookup_path = psprintf("%s/%u/%s", PG_TBLSPC_DIR, spcoid,
                                                                                   tarfilename);
                                }
                                else

diff --git a/src/backend/commands/dbcommands.c b/src/backend/commands/dbcommands.c
index d00ae40e1927d4defb7f2874c34523630553beca..8be435a79e9ed825411fa7eafc3173d040545016 100644 (file)
--- a/src/backend/commands/dbcommands.c
+++ b/src/backend/commands/dbcommands.c
@@ -3257,7 +3257,7 @@ recovery_create_dbdir(char *path, bool only_tblspc)
        if (stat(path, &st) == 0)
                return;
 
-       if (only_tblspc && strstr(path, "pg_tblspc/") == NULL)
+       if (only_tblspc && strstr(path, PG_TBLSPC_DIR_SLASH) == NULL)
                elog(PANIC, "requested to created invalid directory: %s", path);
 
        if (reachedConsistency && !allow_in_place_tablespaces)

diff --git a/src/backend/commands/tablespace.c b/src/backend/commands/tablespace.c
index 113b480731595858d597c30b5f174ef7d14adeb8..00c1ed19fdfd91cefcff0377bad6901690868efe 100644 (file)
--- a/src/backend/commands/tablespace.c
+++ b/src/backend/commands/tablespace.c
@@ -576,7 +576,7 @@ create_tablespace_directories(const char *location, const Oid tablespaceoid)
        struct stat st;
        bool            in_place;
 
-       linkloc = psprintf("pg_tblspc/%u", tablespaceoid);
+       linkloc = psprintf("%s/%u", PG_TBLSPC_DIR, tablespaceoid);
 
        /*
         * If we're asked to make an 'in place' tablespace, create the directory
@@ -692,7 +692,7 @@ destroy_tablespace_directories(Oid tablespaceoid, bool redo)
        char       *subfile;
        struct stat st;
 
-       linkloc_with_version_dir = psprintf("pg_tblspc/%u/%s", tablespaceoid,
+       linkloc_with_version_dir = psprintf("%s/%u/%s", PG_TBLSPC_DIR, tablespaceoid,
                                                                                TABLESPACE_VERSION_DIRECTORY);
 
        /*

diff --git a/src/backend/storage/file/fd.c b/src/backend/storage/file/fd.c
index 368cc9455cf7612fefe5ef03bde416f984776ec0..d5204b1eb910991b0f89a4092345e6bb4fb58166 100644 (file)
--- a/src/backend/storage/file/fd.c
+++ b/src/backend/storage/file/fd.c
@@ -1790,8 +1790,8 @@ TempTablespacePath(char *path, Oid tablespace)
        else
        {
                /* All other tablespaces are accessed via symlinks */
-               snprintf(path, MAXPGPATH, "pg_tblspc/%u/%s/%s",
-                                tablespace, TABLESPACE_VERSION_DIRECTORY,
+               snprintf(path, MAXPGPATH, "%s/%u/%s/%s",
+                                PG_TBLSPC_DIR, tablespace, TABLESPACE_VERSION_DIRECTORY,
                                 PG_TEMP_FILES_DIR);
        }
 }
@@ -3296,7 +3296,7 @@ CleanupTempFiles(bool isCommit, bool isProcExit)
 void
 RemovePgTempFiles(void)
 {
-       char            temp_path[MAXPGPATH + 10 + sizeof(TABLESPACE_VERSION_DIRECTORY) + sizeof(PG_TEMP_FILES_DIR)];
+       char            temp_path[MAXPGPATH + sizeof(PG_TBLSPC_DIR) + sizeof(TABLESPACE_VERSION_DIRECTORY) + sizeof(PG_TEMP_FILES_DIR)];
        DIR                *spc_dir;
        struct dirent *spc_de;
 
@@ -3310,20 +3310,21 @@ RemovePgTempFiles(void)
        /*
         * Cycle through temp directories for all non-default tablespaces.
         */
-       spc_dir = AllocateDir("pg_tblspc");
+       spc_dir = AllocateDir(PG_TBLSPC_DIR);
 
-       while ((spc_de = ReadDirExtended(spc_dir, "pg_tblspc", LOG)) != NULL)
+       while ((spc_de = ReadDirExtended(spc_dir, PG_TBLSPC_DIR, LOG)) != NULL)
        {
                if (strcmp(spc_de->d_name, ".") == 0 ||
                        strcmp(spc_de->d_name, "..") == 0)
                        continue;
 
-               snprintf(temp_path, sizeof(temp_path), "pg_tblspc/%s/%s/%s",
-                                spc_de->d_name, TABLESPACE_VERSION_DIRECTORY, PG_TEMP_FILES_DIR);
+               snprintf(temp_path, sizeof(temp_path), "%s/%s/%s/%s",
+                                PG_TBLSPC_DIR, spc_de->d_name, TABLESPACE_VERSION_DIRECTORY,
+                                PG_TEMP_FILES_DIR);
                RemovePgTempFilesInDir(temp_path, true, false);
 
-               snprintf(temp_path, sizeof(temp_path), "pg_tblspc/%s/%s",
-                                spc_de->d_name, TABLESPACE_VERSION_DIRECTORY);
+               snprintf(temp_path, sizeof(temp_path), "%s/%s/%s",
+                                PG_TBLSPC_DIR, spc_de->d_name, TABLESPACE_VERSION_DIRECTORY);
                RemovePgTempRelationFiles(temp_path);
        }
 
@@ -3610,15 +3611,15 @@ SyncDataDirectory(void)
                /* Sync the top level pgdata directory. */
                do_syncfs(".");
                /* If any tablespaces are configured, sync each of those. */
-               dir = AllocateDir("pg_tblspc");
-               while ((de = ReadDirExtended(dir, "pg_tblspc", LOG)))
+               dir = AllocateDir(PG_TBLSPC_DIR);
+               while ((de = ReadDirExtended(dir, PG_TBLSPC_DIR, LOG)))
                {
                        char            path[MAXPGPATH];
 
                        if (strcmp(de->d_name, ".") == 0 || strcmp(de->d_name, "..") == 0)
                                continue;
 
-                       snprintf(path, MAXPGPATH, "pg_tblspc/%s", de->d_name);
+                       snprintf(path, MAXPGPATH, "%s/%s", PG_TBLSPC_DIR, de->d_name);
                        do_syncfs(path);
                }
                FreeDir(dir);
@@ -3641,7 +3642,7 @@ SyncDataDirectory(void)
        walkdir(".", pre_sync_fname, false, DEBUG1);
        if (xlog_is_symlink)
                walkdir("pg_wal", pre_sync_fname, false, DEBUG1);
-       walkdir("pg_tblspc", pre_sync_fname, true, DEBUG1);
+       walkdir(PG_TBLSPC_DIR, pre_sync_fname, true, DEBUG1);
 #endif
 
        /* Prepare to report progress syncing the data directory via fsync. */
@@ -3659,7 +3660,7 @@ SyncDataDirectory(void)
        walkdir(".", datadir_fsync_fname, false, LOG);
        if (xlog_is_symlink)
                walkdir("pg_wal", datadir_fsync_fname, false, LOG);
-       walkdir("pg_tblspc", datadir_fsync_fname, true, LOG);
+       walkdir(PG_TBLSPC_DIR, datadir_fsync_fname, true, LOG);
 }
 
 /*

diff --git a/src/backend/storage/file/reinit.c b/src/backend/storage/file/reinit.c
index f1cd1a38d95d4f079511dd9d106cd513cb002e3e..01e267abf9b9663ba534bd2ce6dc83e33ed1ea42 100644 (file)
--- a/src/backend/storage/file/reinit.c
+++ b/src/backend/storage/file/reinit.c
@@ -46,7 +46,7 @@ typedef struct
 void
 ResetUnloggedRelations(int op)
 {
-       char            temp_path[MAXPGPATH + 10 + sizeof(TABLESPACE_VERSION_DIRECTORY)];
+       char            temp_path[MAXPGPATH + sizeof(PG_TBLSPC_DIR) + sizeof(TABLESPACE_VERSION_DIRECTORY)];
        DIR                *spc_dir;
        struct dirent *spc_de;
        MemoryContext tmpctx,
@@ -77,16 +77,16 @@ ResetUnloggedRelations(int op)
        /*
         * Cycle through directories for all non-default tablespaces.
         */
-       spc_dir = AllocateDir("pg_tblspc");
+       spc_dir = AllocateDir(PG_TBLSPC_DIR);
 
-       while ((spc_de = ReadDir(spc_dir, "pg_tblspc")) != NULL)
+       while ((spc_de = ReadDir(spc_dir, PG_TBLSPC_DIR)) != NULL)
        {
                if (strcmp(spc_de->d_name, ".") == 0 ||
                        strcmp(spc_de->d_name, "..") == 0)
                        continue;
 
-               snprintf(temp_path, sizeof(temp_path), "pg_tblspc/%s/%s",
-                                spc_de->d_name, TABLESPACE_VERSION_DIRECTORY);
+               snprintf(temp_path, sizeof(temp_path), "%s/%s/%s",
+                                PG_TBLSPC_DIR, spc_de->d_name, TABLESPACE_VERSION_DIRECTORY);
                ResetUnloggedRelationsInTablespaceDir(temp_path, op);
        }
 

diff --git a/src/backend/utils/adt/dbsize.c b/src/backend/utils/adt/dbsize.c
index b2d9cc2792925686f8225d3e2a7952f49504bc1e..e63e99c141621d67c75efa1fded9d09fac28db05 100644 (file)
--- a/src/backend/utils/adt/dbsize.c
+++ b/src/backend/utils/adt/dbsize.c
@@ -143,7 +143,7 @@ calculate_database_size(Oid dbOid)
        totalsize = db_dir_size(pathname);
 
        /* Scan the non-default tablespaces */
-       snprintf(dirpath, MAXPGPATH, "pg_tblspc");
+       snprintf(dirpath, MAXPGPATH, PG_TBLSPC_DIR);
        dirdesc = AllocateDir(dirpath);
 
        while ((direntry = ReadDir(dirdesc, dirpath)) != NULL)
@@ -154,8 +154,8 @@ calculate_database_size(Oid dbOid)
                        strcmp(direntry->d_name, "..") == 0)
                        continue;
 
-               snprintf(pathname, sizeof(pathname), "pg_tblspc/%s/%s/%u",
-                                direntry->d_name, TABLESPACE_VERSION_DIRECTORY, dbOid);
+               snprintf(pathname, sizeof(pathname), "%s/%s/%s/%u",
+                                PG_TBLSPC_DIR, direntry->d_name, TABLESPACE_VERSION_DIRECTORY, dbOid);
                totalsize += db_dir_size(pathname);
        }
 
@@ -227,7 +227,7 @@ calculate_tablespace_size(Oid tblspcOid)
        else if (tblspcOid == GLOBALTABLESPACE_OID)
                snprintf(tblspcPath, MAXPGPATH, "global");
        else
-               snprintf(tblspcPath, MAXPGPATH, "pg_tblspc/%u/%s", tblspcOid,
+               snprintf(tblspcPath, MAXPGPATH, "%s/%u/%s", PG_TBLSPC_DIR, tblspcOid,
                                 TABLESPACE_VERSION_DIRECTORY);
 
        dirdesc = AllocateDir(tblspcPath);

diff --git a/src/backend/utils/adt/misc.c b/src/backend/utils/adt/misc.c
index 0e6c45807a1ec840068c79a3310e7ebc1a8613f3..1aa8bbb3063cedc45442c911535656bfae098a35 100644 (file)
--- a/src/backend/utils/adt/misc.c
+++ b/src/backend/utils/adt/misc.c
@@ -242,7 +242,7 @@ pg_tablespace_databases(PG_FUNCTION_ARGS)
        if (tablespaceOid == DEFAULTTABLESPACE_OID)
                location = "base";
        else
-               location = psprintf("pg_tblspc/%u/%s", tablespaceOid,
+               location = psprintf("%s/%u/%s", PG_TBLSPC_DIR, tablespaceOid,
                                                        TABLESPACE_VERSION_DIRECTORY);
 
        dirdesc = AllocateDir(location);
@@ -325,7 +325,7 @@ pg_tablespace_location(PG_FUNCTION_ARGS)
         * Find the location of the tablespace by reading the symbolic link that
         * is in pg_tblspc/<oid>.
         */
-       snprintf(sourcepath, sizeof(sourcepath), "pg_tblspc/%u", tablespaceOid);
+       snprintf(sourcepath, sizeof(sourcepath), "%s/%u", PG_TBLSPC_DIR, tablespaceOid);
 
        /*
         * Before reading the link, check if the source path is a link or a

diff --git a/src/backend/utils/cache/relcache.c b/src/backend/utils/cache/relcache.c
index 66ed24e4012763ff7021d43a04e73e3e93556e53..63efc55f09e7e280e9817c33116caed25417df19 100644 (file)
--- a/src/backend/utils/cache/relcache.c
+++ b/src/backend/utils/cache/relcache.c
@@ -6800,10 +6800,10 @@ RelationCacheInitFilePostInvalidate(void)
 void
 RelationCacheInitFileRemove(void)
 {
-       const char *tblspcdir = "pg_tblspc";
+       const char *tblspcdir = PG_TBLSPC_DIR;
        DIR                *dir;
        struct dirent *de;
-       char            path[MAXPGPATH + 10 + sizeof(TABLESPACE_VERSION_DIRECTORY)];
+       char            path[MAXPGPATH + sizeof(PG_TBLSPC_DIR) + sizeof(TABLESPACE_VERSION_DIRECTORY)];
 
        snprintf(path, sizeof(path), "global/%s",
                         RELCACHE_INIT_FILENAME);

diff --git a/src/bin/pg_checksums/pg_checksums.c b/src/bin/pg_checksums/pg_checksums.c
index b5bb0e78875aeed110f54ce634b0362e069efc66..68a68eb0fac5a297a4de5c5c3d728bf9c3253a5d 100644 (file)
--- a/src/bin/pg_checksums/pg_checksums.c
+++ b/src/bin/pg_checksums/pg_checksums.c
@@ -388,7 +388,7 @@ scan_directory(const char *basedir, const char *subdir, bool sizeonly)
                         * is valid, resolving the linked locations and dive into them
                         * directly.
                         */
-                       if (strncmp("pg_tblspc", subdir, strlen("pg_tblspc")) == 0)
+                       if (strncmp(PG_TBLSPC_DIR, subdir, strlen(PG_TBLSPC_DIR)) == 0)
                        {
                                char            tblspc_path[MAXPGPATH];
                                struct stat tblspc_st;
@@ -593,12 +593,12 @@ main(int argc, char *argv[])
                {
                        total_size = scan_directory(DataDir, "global", true);
                        total_size += scan_directory(DataDir, "base", true);
-                       total_size += scan_directory(DataDir, "pg_tblspc", true);
+                       total_size += scan_directory(DataDir, PG_TBLSPC_DIR, true);
                }
 
                (void) scan_directory(DataDir, "global", false);
                (void) scan_directory(DataDir, "base", false);
-               (void) scan_directory(DataDir, "pg_tblspc", false);
+               (void) scan_directory(DataDir, PG_TBLSPC_DIR, false);
 
                if (showprogress)
                        progress_report(true);

diff --git a/src/bin/pg_combinebackup/pg_combinebackup.c b/src/bin/pg_combinebackup/pg_combinebackup.c
index 5e2f4f4b3ddbd84280ca62e6071af78c99690398..05a2ff905b0b77ddc5281ac2721f9dacd1f2ce91 100644 (file)
--- a/src/bin/pg_combinebackup/pg_combinebackup.c
+++ b/src/bin/pg_combinebackup/pg_combinebackup.c
@@ -373,7 +373,7 @@ main(int argc, char *argv[])
                {
                        char            linkpath[MAXPGPATH];
 
-                       snprintf(linkpath, MAXPGPATH, "%s/pg_tblspc/%u", opt.output,
+                       snprintf(linkpath, MAXPGPATH, "%s/%s/%u", opt.output, PG_TBLSPC_DIR,
                                         ts->oid);
 
                        if (opt.dry_run)
@@ -867,12 +867,12 @@ process_directory_recursively(Oid tsoid,
                is_incremental_dir = true;
        else if (relative_path != NULL)
        {
-               is_pg_tblspc = strcmp(relative_path, "pg_tblspc") == 0;
+               is_pg_tblspc = strcmp(relative_path, PG_TBLSPC_DIR) == 0;
                is_pg_wal = (strcmp(relative_path, "pg_wal") == 0 ||
                                         strncmp(relative_path, "pg_wal/", 7) == 0);
                is_incremental_dir = strncmp(relative_path, "base/", 5) == 0 ||
                        strcmp(relative_path, "global") == 0 ||
-                       strncmp(relative_path, "pg_tblspc/", 10) == 0;
+                       strncmp(relative_path, PG_TBLSPC_DIR_SLASH, 10) == 0;
        }
 
        /*
@@ -895,7 +895,7 @@ process_directory_recursively(Oid tsoid,
                strlcpy(ifulldir, input_directory, MAXPGPATH);
                strlcpy(ofulldir, output_directory, MAXPGPATH);
                if (OidIsValid(tsoid))
-                       snprintf(manifest_prefix, MAXPGPATH, "pg_tblspc/%u/", tsoid);
+                       snprintf(manifest_prefix, MAXPGPATH, "%s/%u/", PG_TBLSPC_DIR, tsoid);
                else
                        manifest_prefix[0] = '\0';
        }
@@ -906,8 +906,8 @@ process_directory_recursively(Oid tsoid,
                snprintf(ofulldir, MAXPGPATH, "%s/%s", output_directory,
                                 relative_path);
                if (OidIsValid(tsoid))
-                       snprintf(manifest_prefix, MAXPGPATH, "pg_tblspc/%u/%s/",
-                                        tsoid, relative_path);
+                       snprintf(manifest_prefix, MAXPGPATH, "%s/%u/%s/",
+                                        PG_TBLSPC_DIR, tsoid, relative_path);
                else
                        snprintf(manifest_prefix, MAXPGPATH, "%s/", relative_path);
        }
@@ -1249,7 +1249,7 @@ scan_for_existing_tablespaces(char *pathname, cb_options *opt)
        struct dirent *de;
        cb_tablespace *tslist = NULL;
 
-       snprintf(pg_tblspc, MAXPGPATH, "%s/pg_tblspc", pathname);
+       snprintf(pg_tblspc, MAXPGPATH, "%s/%s", pathname, PG_TBLSPC_DIR);
        pg_log_debug("scanning \"%s\"", pg_tblspc);
 
        if ((dir = opendir(pg_tblspc)) == NULL)
@@ -1344,8 +1344,8 @@ scan_for_existing_tablespaces(char *pathname, cb_options *opt)
                         * we just record the paths within the data directories.
                         */
                        snprintf(ts->old_dir, MAXPGPATH, "%s/%s", pg_tblspc, de->d_name);
-                       snprintf(ts->new_dir, MAXPGPATH, "%s/pg_tblspc/%s", opt->output,
-                                        de->d_name);
+                       snprintf(ts->new_dir, MAXPGPATH, "%s/%s/%s", opt->output,
+                                        PG_TBLSPC_DIR, de->d_name);
                        ts->in_place = true;
                }
 

diff --git a/src/bin/pg_rewind/file_ops.c b/src/bin/pg_rewind/file_ops.c
index d93580bb41913b523554937e601895b1db34331a..67a86bb4c5f36472bb2db851770ff799ff320a03 100644 (file)
--- a/src/bin/pg_rewind/file_ops.c
+++ b/src/bin/pg_rewind/file_ops.c
@@ -452,7 +452,7 @@ recurse_dir(const char *datadir, const char *parentpath,
                         * to process all the tablespaces.  We also follow a symlink if
                         * it's for pg_wal.  Symlinks elsewhere are ignored.
                         */
-                       if ((parentpath && strcmp(parentpath, "pg_tblspc") == 0) ||
+                       if ((parentpath && strcmp(parentpath, PG_TBLSPC_DIR) == 0) ||
                                strcmp(path, "pg_wal") == 0)
                                recurse_dir(datadir, path, callback);
                }

diff --git a/src/bin/pg_upgrade/exec.c b/src/bin/pg_upgrade/exec.c
index 058530ab3e9e677091dc45c7889081bcc712007b..78db321acef74f52a15fa21ca7dc23767faac50b 100644 (file)
--- a/src/bin/pg_upgrade/exec.c
+++ b/src/bin/pg_upgrade/exec.c
@@ -350,7 +350,7 @@ check_data_dir(ClusterInfo *cluster)
        check_single_dir(pg_data, "global");
        check_single_dir(pg_data, "pg_multixact");
        check_single_dir(pg_data, "pg_subtrans");
-       check_single_dir(pg_data, "pg_tblspc");
+       check_single_dir(pg_data, PG_TBLSPC_DIR);
        check_single_dir(pg_data, "pg_twophase");
 
        /* pg_xlog has been renamed to pg_wal in v10 */

diff --git a/src/common/file_utils.c b/src/common/file_utils.c
index 6bac537a1e55c4492784f4194c01a1871bf49b28..398fe1c334daeee78b7ed69f3110bbc1f98321ac 100644 (file)
--- a/src/common/file_utils.c
+++ b/src/common/file_utils.c
@@ -28,6 +28,7 @@
 #ifdef FRONTEND
 #include "common/logging.h"
 #endif
+#include "common/relpath.h"
 #include "port/pg_iovec.h"
 
 #ifdef FRONTEND
@@ -105,7 +106,7 @@ sync_pgdata(const char *pg_data,
        /* handle renaming of pg_xlog to pg_wal in post-10 clusters */
        snprintf(pg_wal, MAXPGPATH, "%s/%s", pg_data,
                         serverVersion < MINIMUM_VERSION_FOR_PG_WAL ? "pg_xlog" : "pg_wal");
-       snprintf(pg_tblspc, MAXPGPATH, "%s/pg_tblspc", pg_data);
+       snprintf(pg_tblspc, MAXPGPATH, "%s/%s", pg_data, PG_TBLSPC_DIR);
 
        /*
         * If pg_wal is a symlink, we'll need to recurse into it separately,

diff --git a/src/common/relpath.c b/src/common/relpath.c
index f54c36ef7ac9f849b368ffc67ae103f259c87c32..9f2e00e83e4b3a0889772d419546aef3f9a3ecde 100644 (file)
--- a/src/common/relpath.c
+++ b/src/common/relpath.c
@@ -123,8 +123,9 @@ GetDatabasePath(Oid dbOid, Oid spcOid)
        else
        {
                /* All other tablespaces are accessed via symlinks */
-               return psprintf("pg_tblspc/%u/%s/%u",
-                                               spcOid, TABLESPACE_VERSION_DIRECTORY, dbOid);
+               return psprintf("%s/%u/%s/%u",
+                                               PG_TBLSPC_DIR, spcOid,
+                                               TABLESPACE_VERSION_DIRECTORY, dbOid);
        }
 }
 
@@ -184,25 +185,29 @@ GetRelationPath(Oid dbOid, Oid spcOid, RelFileNumber relNumber,
                if (procNumber == INVALID_PROC_NUMBER)
                {
                        if (forkNumber != MAIN_FORKNUM)
-                               path = psprintf("pg_tblspc/%u/%s/%u/%u_%s",
-                                                               spcOid, TABLESPACE_VERSION_DIRECTORY,
+                               path = psprintf("%s/%u/%s/%u/%u_%s",
+                                                               PG_TBLSPC_DIR, spcOid,
+                                                               TABLESPACE_VERSION_DIRECTORY,
                                                                dbOid, relNumber,
                                                                forkNames[forkNumber]);
                        else
-                               path = psprintf("pg_tblspc/%u/%s/%u/%u",
-                                                               spcOid, TABLESPACE_VERSION_DIRECTORY,
+                               path = psprintf("%s/%u/%s/%u/%u",
+                                                               PG_TBLSPC_DIR, spcOid,
+                                                               TABLESPACE_VERSION_DIRECTORY,
                                                                dbOid, relNumber);
                }
                else
                {
                        if (forkNumber != MAIN_FORKNUM)
-                               path = psprintf("pg_tblspc/%u/%s/%u/t%d_%u_%s",
-                                                               spcOid, TABLESPACE_VERSION_DIRECTORY,
+                               path = psprintf("%s/%u/%s/%u/t%d_%u_%s",
+                                                               PG_TBLSPC_DIR, spcOid,
+                                                               TABLESPACE_VERSION_DIRECTORY,
                                                                dbOid, procNumber, relNumber,
                                                                forkNames[forkNumber]);
                        else
-                               path = psprintf("pg_tblspc/%u/%s/%u/t%d_%u",
-                                                               spcOid, TABLESPACE_VERSION_DIRECTORY,
+                               path = psprintf("%s/%u/%s/%u/t%d_%u",
+                                                               PG_TBLSPC_DIR, spcOid,
+                                                               TABLESPACE_VERSION_DIRECTORY,
                                                                dbOid, procNumber, relNumber);
                }
        }

diff --git a/src/include/common/relpath.h b/src/include/common/relpath.h
index 6f006d5a938c504de8336999c8a2fc897c7c3feb..2dabbe01ecd36a1b2a7dce6316b40e7041ddcec6 100644 (file)
--- a/src/include/common/relpath.h
+++ b/src/include/common/relpath.h
@@ -33,6 +33,15 @@ typedef Oid RelFileNumber;
 #define TABLESPACE_VERSION_DIRECTORY   "PG_" PG_MAJORVERSION "_" \
                                                                        CppAsString2(CATALOG_VERSION_NO)
 
+/*
+ * Tablespace path (relative to installation's $PGDATA).
+ *
+ * These values should not be changed as many tools rely on it.
+ */
+#define PG_TBLSPC_DIR "pg_tblspc"
+#define PG_TBLSPC_DIR_SLASH "pg_tblspc/"       /* required for strings
+                                                                                        * comparisons */
+
 /* Characters to allow for an OID in a relation path */
 #define OIDCHARS               10              /* max chars printed by %u */