aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--src/bin/pg_basebackup/pg_basebackup.c18
-rw-r--r--src/bin/pg_basebackup/pg_receivewal.c44
-rw-r--r--src/bin/pg_basebackup/receivelog.c2
-rw-r--r--src/bin/pg_basebackup/walmethods.c96
-rw-r--r--src/bin/pg_basebackup/walmethods.h16
5 files changed, 84 insertions, 92 deletions
diff --git a/src/bin/pg_basebackup/pg_basebackup.c b/src/bin/pg_basebackup/pg_basebackup.c
index 91bdaf6cc2d..6be04544763 100644
--- a/src/bin/pg_basebackup/pg_basebackup.c
+++ b/src/bin/pg_basebackup/pg_basebackup.c
@@ -520,7 +520,7 @@ typedef struct
char xlog[MAXPGPATH]; /* directory or tarfile depending on mode */
char *sysidentifier;
int timeline;
- WalCompressionMethod wal_compress_method;
+ pg_compress_algorithm wal_compress_algorithm;
int wal_compress_level;
} logstreamer_param;
@@ -550,11 +550,11 @@ LogStreamerMain(logstreamer_param *param)
stream.replication_slot = replication_slot;
if (format == 'p')
stream.walmethod = CreateWalDirectoryMethod(param->xlog,
- COMPRESSION_NONE, 0,
+ PG_COMPRESSION_NONE, 0,
stream.do_sync);
else
stream.walmethod = CreateWalTarMethod(param->xlog,
- param->wal_compress_method,
+ param->wal_compress_algorithm,
param->wal_compress_level,
stream.do_sync);
@@ -602,7 +602,7 @@ LogStreamerMain(logstreamer_param *param)
*/
static void
StartLogStreamer(char *startpos, uint32 timeline, char *sysidentifier,
- WalCompressionMethod wal_compress_method,
+ pg_compress_algorithm wal_compress_algorithm,
int wal_compress_level)
{
logstreamer_param *param;
@@ -613,7 +613,7 @@ StartLogStreamer(char *startpos, uint32 timeline, char *sysidentifier,
param = pg_malloc0(sizeof(logstreamer_param));
param->timeline = timeline;
param->sysidentifier = sysidentifier;
- param->wal_compress_method = wal_compress_method;
+ param->wal_compress_algorithm = wal_compress_algorithm;
param->wal_compress_level = wal_compress_level;
/* Convert the starting position */
@@ -2019,7 +2019,7 @@ BaseBackup(char *compression_algorithm, char *compression_detail,
*/
if (includewal == STREAM_WAL)
{
- WalCompressionMethod wal_compress_method;
+ pg_compress_algorithm wal_compress_algorithm;
int wal_compress_level;
if (verbose)
@@ -2027,19 +2027,19 @@ BaseBackup(char *compression_algorithm, char *compression_detail,
if (client_compress->algorithm == PG_COMPRESSION_GZIP)
{
- wal_compress_method = COMPRESSION_GZIP;
+ wal_compress_algorithm = PG_COMPRESSION_GZIP;
wal_compress_level =
(client_compress->options & PG_COMPRESSION_OPTION_LEVEL)
!= 0 ? client_compress->level : 0;
}
else
{
- wal_compress_method = COMPRESSION_NONE;
+ wal_compress_algorithm = PG_COMPRESSION_NONE;
wal_compress_level = 0;
}
StartLogStreamer(xlogstart, starttli, sysidentifier,
- wal_compress_method, wal_compress_level);
+ wal_compress_algorithm, wal_compress_level);
}
if (serverMajor >= 1500)
diff --git a/src/bin/pg_basebackup/pg_receivewal.c b/src/bin/pg_basebackup/pg_receivewal.c
index 23e04741fd5..ede1d4648d8 100644
--- a/src/bin/pg_basebackup/pg_receivewal.c
+++ b/src/bin/pg_basebackup/pg_receivewal.c
@@ -52,7 +52,7 @@ static bool do_drop_slot = false;
static bool do_sync = true;
static bool synchronous = false;
static char *replication_slot = NULL;
-static WalCompressionMethod compression_method = COMPRESSION_NONE;
+static pg_compress_algorithm compression_algorithm = PG_COMPRESSION_NONE;
static XLogRecPtr endpos = InvalidXLogRecPtr;
@@ -114,7 +114,7 @@ usage(void)
*/
static bool
is_xlogfilename(const char *filename, bool *ispartial,
- WalCompressionMethod *wal_compression_method)
+ pg_compress_algorithm *wal_compression_algorithm)
{
size_t fname_len = strlen(filename);
size_t xlog_pattern_len = strspn(filename, "0123456789ABCDEF");
@@ -127,7 +127,7 @@ is_xlogfilename(const char *filename, bool *ispartial,
if (fname_len == XLOG_FNAME_LEN)
{
*ispartial = false;
- *wal_compression_method = COMPRESSION_NONE;
+ *wal_compression_algorithm = PG_COMPRESSION_NONE;
return true;
}
@@ -136,7 +136,7 @@ is_xlogfilename(const char *filename, bool *ispartial,
strcmp(filename + XLOG_FNAME_LEN, ".gz") == 0)
{
*ispartial = false;
- *wal_compression_method = COMPRESSION_GZIP;
+ *wal_compression_algorithm = PG_COMPRESSION_GZIP;
return true;
}
@@ -145,7 +145,7 @@ is_xlogfilename(const char *filename, bool *ispartial,
strcmp(filename + XLOG_FNAME_LEN, ".lz4") == 0)
{
*ispartial = false;
- *wal_compression_method = COMPRESSION_LZ4;
+ *wal_compression_algorithm = PG_COMPRESSION_LZ4;
return true;
}
@@ -154,7 +154,7 @@ is_xlogfilename(const char *filename, bool *ispartial,
strcmp(filename + XLOG_FNAME_LEN, ".partial") == 0)
{
*ispartial = true;
- *wal_compression_method = COMPRESSION_NONE;
+ *wal_compression_algorithm = PG_COMPRESSION_NONE;
return true;
}
@@ -163,7 +163,7 @@ is_xlogfilename(const char *filename, bool *ispartial,
strcmp(filename + XLOG_FNAME_LEN, ".gz.partial") == 0)
{
*ispartial = true;
- *wal_compression_method = COMPRESSION_GZIP;
+ *wal_compression_algorithm = PG_COMPRESSION_GZIP;
return true;
}
@@ -172,7 +172,7 @@ is_xlogfilename(const char *filename, bool *ispartial,
strcmp(filename + XLOG_FNAME_LEN, ".lz4.partial") == 0)
{
*ispartial = true;
- *wal_compression_method = COMPRESSION_LZ4;
+ *wal_compression_algorithm = PG_COMPRESSION_LZ4;
return true;
}
@@ -279,11 +279,11 @@ FindStreamingStart(uint32 *tli)
{
uint32 tli;
XLogSegNo segno;
- WalCompressionMethod wal_compression_method;
+ pg_compress_algorithm wal_compression_algorithm;
bool ispartial;
if (!is_xlogfilename(dirent->d_name,
- &ispartial, &wal_compression_method))
+ &ispartial, &wal_compression_algorithm))
continue;
/*
@@ -309,7 +309,7 @@ FindStreamingStart(uint32 *tli)
* where WAL segments could have been compressed by a different source
* than pg_receivewal, like an archive_command with lz4.
*/
- if (!ispartial && wal_compression_method == COMPRESSION_NONE)
+ if (!ispartial && wal_compression_algorithm == PG_COMPRESSION_NONE)
{
struct stat statbuf;
char fullpath[MAXPGPATH * 2];
@@ -325,7 +325,7 @@ FindStreamingStart(uint32 *tli)
continue;
}
}
- else if (!ispartial && wal_compression_method == COMPRESSION_GZIP)
+ else if (!ispartial && wal_compression_algorithm == PG_COMPRESSION_GZIP)
{
int fd;
char buf[4];
@@ -364,7 +364,7 @@ FindStreamingStart(uint32 *tli)
continue;
}
}
- else if (!ispartial && wal_compression_method == COMPRESSION_LZ4)
+ else if (!ispartial && wal_compression_algorithm == PG_COMPRESSION_LZ4)
{
#ifdef USE_LZ4
#define LZ4_CHUNK_SZ 64 * 1024 /* 64kB as maximum chunk size read */
@@ -590,7 +590,7 @@ StreamLog(void)
stream.do_sync = do_sync;
stream.mark_done = false;
stream.walmethod = CreateWalDirectoryMethod(basedir,
- compression_method,
+ compression_algorithm,
compresslevel,
stream.do_sync);
stream.partial_suffix = ".partial";
@@ -750,11 +750,11 @@ main(int argc, char **argv)
break;
case 6:
if (pg_strcasecmp(optarg, "gzip") == 0)
- compression_method = COMPRESSION_GZIP;
+ compression_algorithm = PG_COMPRESSION_GZIP;
else if (pg_strcasecmp(optarg, "lz4") == 0)
- compression_method = COMPRESSION_LZ4;
+ compression_algorithm = PG_COMPRESSION_LZ4;
else if (pg_strcasecmp(optarg, "none") == 0)
- compression_method = COMPRESSION_NONE;
+ compression_algorithm = PG_COMPRESSION_NONE;
else
pg_fatal("invalid value \"%s\" for option %s",
optarg, "--compression-method");
@@ -814,9 +814,9 @@ main(int argc, char **argv)
/*
* Compression-related options.
*/
- switch (compression_method)
+ switch (compression_algorithm)
{
- case COMPRESSION_NONE:
+ case PG_COMPRESSION_NONE:
if (compresslevel != 0)
{
pg_log_error("cannot use --compress with --compression-method=%s",
@@ -825,7 +825,7 @@ main(int argc, char **argv)
exit(1);
}
break;
- case COMPRESSION_GZIP:
+ case PG_COMPRESSION_GZIP:
#ifdef HAVE_LIBZ
if (compresslevel == 0)
{
@@ -837,7 +837,7 @@ main(int argc, char **argv)
"gzip");
#endif
break;
- case COMPRESSION_LZ4:
+ case PG_COMPRESSION_LZ4:
#ifdef USE_LZ4
if (compresslevel != 0)
{
@@ -851,7 +851,7 @@ main(int argc, char **argv)
"LZ4");
#endif
break;
- case COMPRESSION_ZSTD:
+ case PG_COMPRESSION_ZSTD:
pg_fatal("compression with %s is not yet supported", "ZSTD");
break;
}
diff --git a/src/bin/pg_basebackup/receivelog.c b/src/bin/pg_basebackup/receivelog.c
index 42d50931d32..ad866a76024 100644
--- a/src/bin/pg_basebackup/receivelog.c
+++ b/src/bin/pg_basebackup/receivelog.c
@@ -114,7 +114,7 @@ open_walfile(StreamCtl *stream, XLogRecPtr startpoint)
* When streaming to tar, no file with this name will exist before, so we
* never have to verify a size.
*/
- if (stream->walmethod->compression_method() == COMPRESSION_NONE &&
+ if (stream->walmethod->compression_algorithm() == PG_COMPRESSION_NONE &&
stream->walmethod->existsfile(fn))
{
size = stream->walmethod->get_file_size(fn);
diff --git a/src/bin/pg_basebackup/walmethods.c b/src/bin/pg_basebackup/walmethods.c
index acd242d2c99..d5bcc208a97 100644
--- a/src/bin/pg_basebackup/walmethods.c
+++ b/src/bin/pg_basebackup/walmethods.c
@@ -49,7 +49,7 @@
typedef struct DirectoryMethodData
{
char *basedir;
- WalCompressionMethod compression_method;
+ pg_compress_algorithm compression_algorithm;
int compression_level;
bool sync;
const char *lasterrstring; /* if set, takes precedence over lasterrno */
@@ -97,8 +97,8 @@ dir_get_file_name(const char *pathname, const char *temp_suffix)
snprintf(filename, MAXPGPATH, "%s%s%s",
pathname,
- dir_data->compression_method == COMPRESSION_GZIP ? ".gz" :
- dir_data->compression_method == COMPRESSION_LZ4 ? ".lz4" : "",
+ dir_data->compression_algorithm == PG_COMPRESSION_GZIP ? ".gz" :
+ dir_data->compression_algorithm == PG_COMPRESSION_LZ4 ? ".lz4" : "",
temp_suffix ? temp_suffix : "");
return filename;
@@ -141,7 +141,7 @@ dir_open_for_write(const char *pathname, const char *temp_suffix, size_t pad_to_
}
#ifdef HAVE_LIBZ
- if (dir_data->compression_method == COMPRESSION_GZIP)
+ if (dir_data->compression_algorithm == PG_COMPRESSION_GZIP)
{
gzfp = gzdopen(fd, "wb");
if (gzfp == NULL)
@@ -161,7 +161,7 @@ dir_open_for_write(const char *pathname, const char *temp_suffix, size_t pad_to_
}
#endif
#ifdef USE_LZ4
- if (dir_data->compression_method == COMPRESSION_LZ4)
+ if (dir_data->compression_algorithm == PG_COMPRESSION_LZ4)
{
size_t ctx_out;
size_t header_size;
@@ -202,7 +202,7 @@ dir_open_for_write(const char *pathname, const char *temp_suffix, size_t pad_to_
#endif
/* Do pre-padding on non-compressed files */
- if (pad_to_size && dir_data->compression_method == COMPRESSION_NONE)
+ if (pad_to_size && dir_data->compression_algorithm == PG_COMPRESSION_NONE)
{
PGAlignedXLogBlock zerobuf;
int bytes;
@@ -241,12 +241,12 @@ dir_open_for_write(const char *pathname, const char *temp_suffix, size_t pad_to_
{
dir_data->lasterrno = errno;
#ifdef HAVE_LIBZ
- if (dir_data->compression_method == COMPRESSION_GZIP)
+ if (dir_data->compression_algorithm == PG_COMPRESSION_GZIP)
gzclose(gzfp);
else
#endif
#ifdef USE_LZ4
- if (dir_data->compression_method == COMPRESSION_LZ4)
+ if (dir_data->compression_algorithm == PG_COMPRESSION_LZ4)
{
(void) LZ4F_compressEnd(ctx, lz4buf, lz4bufsize, NULL);
(void) LZ4F_freeCompressionContext(ctx);
@@ -262,11 +262,11 @@ dir_open_for_write(const char *pathname, const char *temp_suffix, size_t pad_to_
f = pg_malloc0(sizeof(DirectoryMethodFile));
#ifdef HAVE_LIBZ
- if (dir_data->compression_method == COMPRESSION_GZIP)
+ if (dir_data->compression_algorithm == PG_COMPRESSION_GZIP)
f->gzfp = gzfp;
#endif
#ifdef USE_LZ4
- if (dir_data->compression_method == COMPRESSION_LZ4)
+ if (dir_data->compression_algorithm == PG_COMPRESSION_LZ4)
{
f->ctx = ctx;
f->lz4buf = lz4buf;
@@ -294,7 +294,7 @@ dir_write(Walfile f, const void *buf, size_t count)
dir_clear_error();
#ifdef HAVE_LIBZ
- if (dir_data->compression_method == COMPRESSION_GZIP)
+ if (dir_data->compression_algorithm == PG_COMPRESSION_GZIP)
{
errno = 0;
r = (ssize_t) gzwrite(df->gzfp, buf, count);
@@ -307,7 +307,7 @@ dir_write(Walfile f, const void *buf, size_t count)
else
#endif
#ifdef USE_LZ4
- if (dir_data->compression_method == COMPRESSION_LZ4)
+ if (dir_data->compression_algorithm == PG_COMPRESSION_LZ4)
{
size_t chunk;
size_t remaining;
@@ -387,7 +387,7 @@ dir_close(Walfile f, WalCloseMethod method)
dir_clear_error();
#ifdef HAVE_LIBZ
- if (dir_data->compression_method == COMPRESSION_GZIP)
+ if (dir_data->compression_algorithm == PG_COMPRESSION_GZIP)
{
errno = 0; /* in case gzclose() doesn't set it */
r = gzclose(df->gzfp);
@@ -395,7 +395,7 @@ dir_close(Walfile f, WalCloseMethod method)
else
#endif
#ifdef USE_LZ4
- if (dir_data->compression_method == COMPRESSION_LZ4)
+ if (dir_data->compression_algorithm == PG_COMPRESSION_LZ4)
{
size_t compressed;
@@ -514,7 +514,7 @@ dir_sync(Walfile f)
return 0;
#ifdef HAVE_LIBZ
- if (dir_data->compression_method == COMPRESSION_GZIP)
+ if (dir_data->compression_algorithm == PG_COMPRESSION_GZIP)
{
if (gzflush(((DirectoryMethodFile *) f)->gzfp, Z_SYNC_FLUSH) != Z_OK)
{
@@ -524,7 +524,7 @@ dir_sync(Walfile f)
}
#endif
#ifdef USE_LZ4
- if (dir_data->compression_method == COMPRESSION_LZ4)
+ if (dir_data->compression_algorithm == PG_COMPRESSION_LZ4)
{
DirectoryMethodFile *df = (DirectoryMethodFile *) f;
size_t compressed;
@@ -571,10 +571,10 @@ dir_get_file_size(const char *pathname)
return statbuf.st_size;
}
-static WalCompressionMethod
-dir_compression_method(void)
+static pg_compress_algorithm
+dir_compression_algorithm(void)
{
- return dir_data->compression_method;
+ return dir_data->compression_algorithm;
}
static bool
@@ -618,7 +618,7 @@ dir_finish(void)
WalWriteMethod *
CreateWalDirectoryMethod(const char *basedir,
- WalCompressionMethod compression_method,
+ pg_compress_algorithm compression_algorithm,
int compression_level, bool sync)
{
WalWriteMethod *method;
@@ -629,7 +629,7 @@ CreateWalDirectoryMethod(const char *basedir,
method->get_current_pos = dir_get_current_pos;
method->get_file_size = dir_get_file_size;
method->get_file_name = dir_get_file_name;
- method->compression_method = dir_compression_method;
+ method->compression_algorithm = dir_compression_algorithm;
method->close = dir_close;
method->sync = dir_sync;
method->existsfile = dir_existsfile;
@@ -637,7 +637,7 @@ CreateWalDirectoryMethod(const char *basedir,
method->getlasterror = dir_getlasterror;
dir_data = pg_malloc0(sizeof(DirectoryMethodData));
- dir_data->compression_method = compression_method;
+ dir_data->compression_algorithm = compression_algorithm;
dir_data->compression_level = compression_level;
dir_data->basedir = pg_strdup(basedir);
dir_data->sync = sync;
@@ -672,7 +672,7 @@ typedef struct TarMethodData
{
char *tarfilename;
int fd;
- WalCompressionMethod compression_method;
+ pg_compress_algorithm compression_algorithm;
int compression_level;
bool sync;
TarMethodFile *currentfile;
@@ -759,7 +759,7 @@ tar_write(Walfile f, const void *buf, size_t count)
tar_clear_error();
/* Tarfile will always be positioned at the end */
- if (tar_data->compression_method == COMPRESSION_NONE)
+ if (tar_data->compression_algorithm == PG_COMPRESSION_NONE)
{
errno = 0;
r = write(tar_data->fd, buf, count);
@@ -773,7 +773,7 @@ tar_write(Walfile f, const void *buf, size_t count)
return r;
}
#ifdef HAVE_LIBZ
- else if (tar_data->compression_method == COMPRESSION_GZIP)
+ else if (tar_data->compression_algorithm == PG_COMPRESSION_GZIP)
{
if (!tar_write_compressed_data(unconstify(void *, buf), count, false))
return -1;
@@ -842,7 +842,7 @@ tar_open_for_write(const char *pathname, const char *temp_suffix, size_t pad_to_
}
#ifdef HAVE_LIBZ
- if (tar_data->compression_method == COMPRESSION_GZIP)
+ if (tar_data->compression_algorithm == PG_COMPRESSION_GZIP)
{
tar_data->zp = (z_streamp) pg_malloc(sizeof(z_stream));
tar_data->zp->zalloc = Z_NULL;
@@ -893,7 +893,7 @@ tar_open_for_write(const char *pathname, const char *temp_suffix, size_t pad_to_
pg_free(tmppath);
#ifdef HAVE_LIBZ
- if (tar_data->compression_method == COMPRESSION_GZIP)
+ if (tar_data->compression_algorithm == PG_COMPRESSION_GZIP)
{
/* Flush existing data */
if (!tar_write_compressed_data(NULL, 0, true))
@@ -918,7 +918,7 @@ tar_open_for_write(const char *pathname, const char *temp_suffix, size_t pad_to_
}
tar_data->currentfile->currpos = 0;
- if (tar_data->compression_method == COMPRESSION_NONE)
+ if (tar_data->compression_algorithm == PG_COMPRESSION_NONE)
{
errno = 0;
if (write(tar_data->fd, tar_data->currentfile->header,
@@ -932,7 +932,7 @@ tar_open_for_write(const char *pathname, const char *temp_suffix, size_t pad_to_
}
}
#ifdef HAVE_LIBZ
- else if (tar_data->compression_method == COMPRESSION_GZIP)
+ else if (tar_data->compression_algorithm == PG_COMPRESSION_GZIP)
{
/* Write header through the zlib APIs but with no compression */
if (!tar_write_compressed_data(tar_data->currentfile->header,
@@ -962,7 +962,7 @@ tar_open_for_write(const char *pathname, const char *temp_suffix, size_t pad_to_
if (pad_to_size)
{
tar_data->currentfile->pad_to_size = pad_to_size;
- if (tar_data->compression_method == COMPRESSION_NONE)
+ if (tar_data->compression_algorithm == PG_COMPRESSION_NONE)
{
/* Uncompressed, so pad now */
if (!tar_write_padding_data(tar_data->currentfile, pad_to_size))
@@ -993,10 +993,10 @@ tar_get_file_size(const char *pathname)
return -1;
}
-static WalCompressionMethod
-tar_compression_method(void)
+static pg_compress_algorithm
+tar_compression_algorithm(void)
{
- return tar_data->compression_method;
+ return tar_data->compression_algorithm;
}
static off_t
@@ -1023,7 +1023,7 @@ tar_sync(Walfile f)
* Always sync the whole tarfile, because that's all we can do. This makes
* no sense on compressed files, so just ignore those.
*/
- if (tar_data->compression_method != COMPRESSION_NONE)
+ if (tar_data->compression_algorithm != PG_COMPRESSION_NONE)
return 0;
r = fsync(tar_data->fd);
@@ -1044,7 +1044,7 @@ tar_close(Walfile f, WalCloseMethod method)
if (method == CLOSE_UNLINK)
{
- if (tar_data->compression_method != COMPRESSION_NONE)
+ if (tar_data->compression_algorithm != PG_COMPRESSION_NONE)
{
tar_set_error("unlink not supported with compression");
return -1;
@@ -1075,7 +1075,7 @@ tar_close(Walfile f, WalCloseMethod method)
*/
if (tf->pad_to_size)
{
- if (tar_data->compression_method == COMPRESSION_GZIP)
+ if (tar_data->compression_algorithm == PG_COMPRESSION_GZIP)
{
/*
* A compressed tarfile is padded on close since we cannot know
@@ -1116,7 +1116,7 @@ tar_close(Walfile f, WalCloseMethod method)
#ifdef HAVE_LIBZ
- if (tar_data->compression_method == COMPRESSION_GZIP)
+ if (tar_data->compression_algorithm == PG_COMPRESSION_GZIP)
{
/* Flush the current buffer */
if (!tar_write_compressed_data(NULL, 0, true))
@@ -1145,7 +1145,7 @@ tar_close(Walfile f, WalCloseMethod method)
tar_data->lasterrno = errno;
return -1;
}
- if (tar_data->compression_method == COMPRESSION_NONE)
+ if (tar_data->compression_algorithm == PG_COMPRESSION_NONE)
{
errno = 0;
if (write(tar_data->fd, tf->header, TAR_BLOCK_SIZE) != TAR_BLOCK_SIZE)
@@ -1156,7 +1156,7 @@ tar_close(Walfile f, WalCloseMethod method)
}
}
#ifdef HAVE_LIBZ
- else if (tar_data->compression_method == COMPRESSION_GZIP)
+ else if (tar_data->compression_algorithm == PG_COMPRESSION_GZIP)
{
/* Turn off compression */
if (deflateParams(tar_data->zp, 0, 0) != Z_OK)
@@ -1230,7 +1230,7 @@ tar_finish(void)
/* A tarfile always ends with two empty blocks */
MemSet(zerobuf, 0, sizeof(zerobuf));
- if (tar_data->compression_method == COMPRESSION_NONE)
+ if (tar_data->compression_algorithm == PG_COMPRESSION_NONE)
{
errno = 0;
if (write(tar_data->fd, zerobuf, sizeof(zerobuf)) != sizeof(zerobuf))
@@ -1241,7 +1241,7 @@ tar_finish(void)
}
}
#ifdef HAVE_LIBZ
- else if (tar_data->compression_method == COMPRESSION_GZIP)
+ else if (tar_data->compression_algorithm == PG_COMPRESSION_GZIP)
{
if (!tar_write_compressed_data(zerobuf, sizeof(zerobuf), false))
return false;
@@ -1324,18 +1324,18 @@ tar_finish(void)
}
/*
- * The argument compression_method is currently ignored. It is in place for
+ * The argument compression_algorithm is currently ignored. It is in place for
* symmetry with CreateWalDirectoryMethod which uses it for distinguishing
* between the different compression methods. CreateWalTarMethod and its family
* of functions handle only zlib compression.
*/
WalWriteMethod *
CreateWalTarMethod(const char *tarbase,
- WalCompressionMethod compression_method,
+ pg_compress_algorithm compression_algorithm,
int compression_level, bool sync)
{
WalWriteMethod *method;
- const char *suffix = (compression_method == COMPRESSION_GZIP) ?
+ const char *suffix = (compression_algorithm == PG_COMPRESSION_GZIP) ?
".tar.gz" : ".tar";
method = pg_malloc0(sizeof(WalWriteMethod));
@@ -1344,7 +1344,7 @@ CreateWalTarMethod(const char *tarbase,
method->get_current_pos = tar_get_current_pos;
method->get_file_size = tar_get_file_size;
method->get_file_name = tar_get_file_name;
- method->compression_method = tar_compression_method;
+ method->compression_algorithm = tar_compression_algorithm;
method->close = tar_close;
method->sync = tar_sync;
method->existsfile = tar_existsfile;
@@ -1355,11 +1355,11 @@ CreateWalTarMethod(const char *tarbase,
tar_data->tarfilename = pg_malloc0(strlen(tarbase) + strlen(suffix) + 1);
sprintf(tar_data->tarfilename, "%s%s", tarbase, suffix);
tar_data->fd = -1;
- tar_data->compression_method = compression_method;
+ tar_data->compression_algorithm = compression_algorithm;
tar_data->compression_level = compression_level;
tar_data->sync = sync;
#ifdef HAVE_LIBZ
- if (compression_method == COMPRESSION_GZIP)
+ if (compression_algorithm == PG_COMPRESSION_GZIP)
tar_data->zlibOut = (char *) pg_malloc(ZLIB_OUT_SIZE + 1);
#endif
@@ -1371,7 +1371,7 @@ FreeWalTarMethod(void)
{
pg_free(tar_data->tarfilename);
#ifdef HAVE_LIBZ
- if (tar_data->compression_method == COMPRESSION_GZIP)
+ if (tar_data->compression_algorithm == PG_COMPRESSION_GZIP)
pg_free(tar_data->zlibOut);
#endif
pg_free(tar_data);
diff --git a/src/bin/pg_basebackup/walmethods.h b/src/bin/pg_basebackup/walmethods.h
index ec54019cfc3..76530dc9419 100644
--- a/src/bin/pg_basebackup/walmethods.h
+++ b/src/bin/pg_basebackup/walmethods.h
@@ -9,6 +9,7 @@
*-------------------------------------------------------------------------
*/
+#include "common/compression.h"
typedef void *Walfile;
@@ -19,15 +20,6 @@ typedef enum
CLOSE_NO_RENAME
} WalCloseMethod;
-/* Types of compression supported */
-typedef enum
-{
- COMPRESSION_GZIP,
- COMPRESSION_LZ4,
- COMPRESSION_ZSTD,
- COMPRESSION_NONE
-} WalCompressionMethod;
-
/*
* A WalWriteMethod structure represents the different methods used
* to write the streaming WAL as it's received.
@@ -68,7 +60,7 @@ struct WalWriteMethod
char *(*get_file_name) (const char *pathname, const char *temp_suffix);
/* Returns the compression method */
- WalCompressionMethod (*compression_method) (void);
+ pg_compress_algorithm (*compression_algorithm) (void);
/*
* Write count number of bytes to the file, and return the number of bytes
@@ -104,10 +96,10 @@ struct WalWriteMethod
* not all those required for pg_receivewal)
*/
WalWriteMethod *CreateWalDirectoryMethod(const char *basedir,
- WalCompressionMethod compression_method,
+ pg_compress_algorithm compression_algo,
int compression, bool sync);
WalWriteMethod *CreateWalTarMethod(const char *tarbase,
- WalCompressionMethod compression_method,
+ pg_compress_algorithm compression_algo,
int compression, bool sync);
/* Cleanup routines for previously-created methods */
generated by cgit v1.2.3 (git 2.25.1) at 2025-06-21 13:57:20 +0000