PostgreSQL Source Code git master
compress_io.c File Reference
#include "postgres_fe.h"
#include <sys/stat.h>
#include <unistd.h>
#include "compress_gzip.h"
#include "compress_io.h"
#include "compress_lz4.h"
#include "compress_none.h"
#include "compress_zstd.h"
Include dependency graph for compress_io.c:

Go to the source code of this file.

Functions

char * supports_compression (const pg_compress_specification compression_spec)
 
CompressorStateAllocateCompressor (const pg_compress_specification compression_spec, ReadFunc readF, WriteFunc writeF)
 
void EndCompressor (ArchiveHandle *AH, CompressorState *cs)
 
static int hasSuffix (const char *filename, const char *suffix)
 
static void free_keep_errno (void *p)
 
CompressFileHandleInitCompressFileHandle (const pg_compress_specification compression_spec)
 
static bool check_compressed_file (const char *path, char **fname, char *ext)
 
CompressFileHandleInitDiscoverCompressFileHandle (const char *path, const char *mode)
 
bool EndCompressFileHandle (CompressFileHandle *CFH)
 

Function Documentation

◆ AllocateCompressor()

CompressorState * AllocateCompressor ( const pg_compress_specification  compression_spec,
ReadFunc  readF,
WriteFunc  writeF 
)

Definition at line 123 of file compress_io.c.

125{
126 CompressorState *cs;
127
129 cs->readF = readF;
130 cs->writeF = writeF;
131
132 if (compression_spec.algorithm == PG_COMPRESSION_NONE)
133 InitCompressorNone(cs, compression_spec);
134 else if (compression_spec.algorithm == PG_COMPRESSION_GZIP)
135 InitCompressorGzip(cs, compression_spec);
136 else if (compression_spec.algorithm == PG_COMPRESSION_LZ4)
137 InitCompressorLZ4(cs, compression_spec);
138 else if (compression_spec.algorithm == PG_COMPRESSION_ZSTD)
139 InitCompressorZstd(cs, compression_spec);
140
141 return cs;
142}
void InitCompressorGzip(CompressorState *cs, const pg_compress_specification compression_spec)
void InitCompressorLZ4(CompressorState *cs, const pg_compress_specification compression_spec)
Definition: compress_lz4.c:777
void InitCompressorNone(CompressorState *cs, const pg_compress_specification compression_spec)
Definition: compress_none.c:66
void InitCompressorZstd(CompressorState *cs, const pg_compress_specification compression_spec)
Definition: compress_zstd.c:23
@ PG_COMPRESSION_GZIP
Definition: compression.h:24
@ PG_COMPRESSION_LZ4
Definition: compression.h:25
@ PG_COMPRESSION_NONE
Definition: compression.h:23
@ PG_COMPRESSION_ZSTD
Definition: compression.h:26
void * pg_malloc0(size_t size)
Definition: fe_memutils.c:53
ReadFunc readF
Definition: compress_io.h:72
WriteFunc writeF
Definition: compress_io.h:77
pg_compress_algorithm algorithm
Definition: compression.h:34

References pg_compress_specification::algorithm, InitCompressorGzip(), InitCompressorLZ4(), InitCompressorNone(), InitCompressorZstd(), PG_COMPRESSION_GZIP, PG_COMPRESSION_LZ4, PG_COMPRESSION_NONE, PG_COMPRESSION_ZSTD, pg_malloc0(), CompressorState::readF, and CompressorState::writeF.

Referenced by _PrintData(), _StartData(), and _StartLO().

◆ check_compressed_file()

static bool check_compressed_file ( const char *  path,
char **  fname,
char *  ext 
)
static

Definition at line 219 of file compress_io.c.

220{
221 free_keep_errno(*fname);
222 *fname = psprintf("%s.%s", path, ext);
223 return (access(*fname, F_OK) == 0);
224}
static void free_keep_errno(void *p)
Definition: compress_io.c:178
short access
Definition: preproc-type.c:36
char * psprintf(const char *fmt,...)
Definition: psprintf.c:43

References free_keep_errno(), and psprintf().

Referenced by InitDiscoverCompressFileHandle().

◆ EndCompressFileHandle()

bool EndCompressFileHandle ( CompressFileHandle CFH)

Definition at line 288 of file compress_io.c.

289{
290 bool ret = false;
291
292 if (CFH->private_data)
293 ret = CFH->close_func(CFH);
294
295 free_keep_errno(CFH);
296
297 return ret;
298}
bool(* close_func)(CompressFileHandle *CFH)
Definition: compress_io.h:175

References CompressFileHandle::close_func, free_keep_errno(), and CompressFileHandle::private_data.

Referenced by _CloseArchive(), _EndData(), _EndLO(), _EndLOs(), _LoadLOs(), _PrintFileData(), CloseArchive(), InitArchiveFmt_Directory(), and RestoreOutput().

◆ EndCompressor()

void EndCompressor ( ArchiveHandle AH,
CompressorState cs 
)

Definition at line 148 of file compress_io.c.

149{
150 cs->end(AH, cs);
151 pg_free(cs);
152}
void pg_free(void *ptr)
Definition: fe_memutils.c:105
void(* end)(ArchiveHandle *AH, CompressorState *cs)
Definition: compress_io.h:67

References CompressorState::end, and pg_free().

Referenced by _EndData(), _EndLO(), and _PrintData().

◆ free_keep_errno()

static void free_keep_errno ( void *  p)
static

Definition at line 178 of file compress_io.c.

179{
180 int save_errno = errno;
181
182 free(p);
183 errno = save_errno;
184}
#define free(a)
Definition: header.h:65

References free.

Referenced by check_compressed_file(), EndCompressFileHandle(), and InitDiscoverCompressFileHandle().

◆ hasSuffix()

static int hasSuffix ( const char *  filename,
const char *  suffix 
)
static

Definition at line 163 of file compress_io.c.

164{
165 int filenamelen = strlen(filename);
166 int suffixlen = strlen(suffix);
167
168 if (filenamelen < suffixlen)
169 return 0;
170
171 return memcmp(&filename[filenamelen - suffixlen],
172 suffix,
173 suffixlen) == 0;
174}
static char * filename
Definition: pg_dumpall.c:124

References filename.

Referenced by InitDiscoverCompressFileHandle().

◆ InitCompressFileHandle()

CompressFileHandle * InitCompressFileHandle ( const pg_compress_specification  compression_spec)

Definition at line 194 of file compress_io.c.

195{
197
198 CFH = pg_malloc0(sizeof(CompressFileHandle));
199
200 if (compression_spec.algorithm == PG_COMPRESSION_NONE)
201 InitCompressFileHandleNone(CFH, compression_spec);
202 else if (compression_spec.algorithm == PG_COMPRESSION_GZIP)
203 InitCompressFileHandleGzip(CFH, compression_spec);
204 else if (compression_spec.algorithm == PG_COMPRESSION_LZ4)
205 InitCompressFileHandleLZ4(CFH, compression_spec);
206 else if (compression_spec.algorithm == PG_COMPRESSION_ZSTD)
207 InitCompressFileHandleZstd(CFH, compression_spec);
208
209 return CFH;
210}
void InitCompressFileHandleGzip(CompressFileHandle *CFH, const pg_compress_specification compression_spec)
void InitCompressFileHandleLZ4(CompressFileHandle *CFH, const pg_compress_specification compression_spec)
Definition: compress_lz4.c:784
void InitCompressFileHandleNone(CompressFileHandle *CFH, const pg_compress_specification compression_spec)
void InitCompressFileHandleZstd(CompressFileHandle *CFH, const pg_compress_specification compression_spec)
Definition: compress_zstd.c:29

References pg_compress_specification::algorithm, InitCompressFileHandleGzip(), InitCompressFileHandleLZ4(), InitCompressFileHandleNone(), InitCompressFileHandleZstd(), PG_COMPRESSION_GZIP, PG_COMPRESSION_LZ4, PG_COMPRESSION_NONE, PG_COMPRESSION_ZSTD, and pg_malloc0().

Referenced by _allocAH(), _CloseArchive(), _StartData(), _StartLO(), _StartLOs(), InitDiscoverCompressFileHandle(), and SetOutput().

◆ InitDiscoverCompressFileHandle()

CompressFileHandle * InitDiscoverCompressFileHandle ( const char *  path,
const char *  mode 
)

Definition at line 240 of file compress_io.c.

241{
242 CompressFileHandle *CFH = NULL;
243 struct stat st;
244 char *fname;
245 pg_compress_specification compression_spec = {0};
246
247 compression_spec.algorithm = PG_COMPRESSION_NONE;
248
249 Assert(strcmp(mode, PG_BINARY_R) == 0);
250
251 fname = pg_strdup(path);
252
253 if (hasSuffix(fname, ".gz"))
254 compression_spec.algorithm = PG_COMPRESSION_GZIP;
255 else if (hasSuffix(fname, ".lz4"))
256 compression_spec.algorithm = PG_COMPRESSION_LZ4;
257 else if (hasSuffix(fname, ".zst"))
258 compression_spec.algorithm = PG_COMPRESSION_ZSTD;
259 else
260 {
261 if (stat(path, &st) == 0)
262 compression_spec.algorithm = PG_COMPRESSION_NONE;
263 else if (check_compressed_file(path, &fname, "gz"))
264 compression_spec.algorithm = PG_COMPRESSION_GZIP;
265 else if (check_compressed_file(path, &fname, "lz4"))
266 compression_spec.algorithm = PG_COMPRESSION_LZ4;
267 else if (check_compressed_file(path, &fname, "zst"))
268 compression_spec.algorithm = PG_COMPRESSION_ZSTD;
269 }
270
271 CFH = InitCompressFileHandle(compression_spec);
272 if (!CFH->open_func(fname, -1, mode, CFH))
273 {
274 free_keep_errno(CFH);
275 CFH = NULL;
276 }
277 free_keep_errno(fname);
278
279 return CFH;
280}
#define PG_BINARY_R
Definition: c.h:1246
static int hasSuffix(const char *filename, const char *suffix)
Definition: compress_io.c:163
CompressFileHandle * InitCompressFileHandle(const pg_compress_specification compression_spec)
Definition: compress_io.c:194
static bool check_compressed_file(const char *path, char **fname, char *ext)
Definition: compress_io.c:219
char * pg_strdup(const char *in)
Definition: fe_memutils.c:85
Assert(PointerIsAligned(start, uint64))
static PgChecksumMode mode
Definition: pg_checksums.c:55
bool(* open_func)(const char *path, int fd, const char *mode, CompressFileHandle *CFH)
Definition: compress_io.h:111
#define stat
Definition: win32_port.h:274

References pg_compress_specification::algorithm, Assert(), check_compressed_file(), free_keep_errno(), hasSuffix(), InitCompressFileHandle(), mode, CompressFileHandle::open_func, PG_BINARY_R, PG_COMPRESSION_GZIP, PG_COMPRESSION_LZ4, PG_COMPRESSION_NONE, PG_COMPRESSION_ZSTD, pg_strdup(), and stat.

Referenced by _LoadLOs(), _PrintFileData(), and InitArchiveFmt_Directory().

◆ supports_compression()

char * supports_compression ( const pg_compress_specification  compression_spec)

Definition at line 87 of file compress_io.c.

88{
89 const pg_compress_algorithm algorithm = compression_spec.algorithm;
90 bool supported = false;
91
92 if (algorithm == PG_COMPRESSION_NONE)
93 supported = true;
94#ifdef HAVE_LIBZ
95 if (algorithm == PG_COMPRESSION_GZIP)
96 supported = true;
97#endif
98#ifdef USE_LZ4
99 if (algorithm == PG_COMPRESSION_LZ4)
100 supported = true;
101#endif
102#ifdef USE_ZSTD
103 if (algorithm == PG_COMPRESSION_ZSTD)
104 supported = true;
105#endif
106
107 if (!supported)
108 return psprintf(_("this build does not support compression with %s"),
109 get_compress_algorithm_name(algorithm));
110
111 return NULL;
112}
const char * get_compress_algorithm_name(pg_compress_algorithm algorithm)
Definition: compression.c:69
pg_compress_algorithm
Definition: compression.h:22
#define _(x)
Definition: elog.c:90

References _, pg_compress_specification::algorithm, get_compress_algorithm_name(), PG_COMPRESSION_GZIP, PG_COMPRESSION_LZ4, PG_COMPRESSION_NONE, PG_COMPRESSION_ZSTD, and psprintf().

Referenced by main(), ReadHead(), and RestoreArchive().