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)
CompressorState *	AllocateCompressor (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)
CompressFileHandle *	InitCompressFileHandle (const pg_compress_specification compression_spec)
static bool	check_compressed_file (const char *path, char **fname, char *ext)
CompressFileHandle *	InitDiscoverCompressFileHandle (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.

{
    CompressorState *cs;
 
    cs = (CompressorState *) pg_malloc0(sizeof(CompressorState));
    cs->readF = readF;
    cs->writeF = writeF;
 
    if (compression_spec.algorithm == PG_COMPRESSION_NONE)
        InitCompressorNone(cs, compression_spec);
    else if (compression_spec.algorithm == PG_COMPRESSION_GZIP)
        InitCompressorGzip(cs, compression_spec);
    else if (compression_spec.algorithm == PG_COMPRESSION_LZ4)
        InitCompressorLZ4(cs, compression_spec);
    else if (compression_spec.algorithm == PG_COMPRESSION_ZSTD)
        InitCompressorZstd(cs, compression_spec);
 
    return cs;
}

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.

{
    free_keep_errno(*fname);
    *fname = psprintf("%s.%s", path, ext);
    return (access(*fname, F_OK) == 0);
}

References free_keep_errno(), and psprintf().

Referenced by InitDiscoverCompressFileHandle().

EndCompressFileHandle()

bool EndCompressFileHandle

(

CompressFileHandle *

CFH

)

Definition at line 288 of file compress_io.c.

{
    bool        ret = false;
 
    if (CFH->private_data)
        ret = CFH->close_func(CFH);
 
    free_keep_errno(CFH);
 
    return ret;
}

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.

{
    cs->end(AH, cs);
    pg_free(cs);
}

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.

{
    int         save_errno = errno;
 
    free(p);
    errno = save_errno;
}

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.

{
    int         filenamelen = strlen(filename);
    int         suffixlen = strlen(suffix);
 
    if (filenamelen < suffixlen)
        return 0;
 
    return memcmp(&filename[filenamelen - suffixlen],
                  suffix,
                  suffixlen) == 0;
}

References filename.

Referenced by InitDiscoverCompressFileHandle().

InitCompressFileHandle()

CompressFileHandle * InitCompressFileHandle

(

const pg_compress_specification

compression_spec

)

Definition at line 194 of file compress_io.c.

{
    CompressFileHandle *CFH;
 
    CFH = pg_malloc0(sizeof(CompressFileHandle));
 
    if (compression_spec.algorithm == PG_COMPRESSION_NONE)
        InitCompressFileHandleNone(CFH, compression_spec);
    else if (compression_spec.algorithm == PG_COMPRESSION_GZIP)
        InitCompressFileHandleGzip(CFH, compression_spec);
    else if (compression_spec.algorithm == PG_COMPRESSION_LZ4)
        InitCompressFileHandleLZ4(CFH, compression_spec);
    else if (compression_spec.algorithm == PG_COMPRESSION_ZSTD)
        InitCompressFileHandleZstd(CFH, compression_spec);
 
    return CFH;
}

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.

{
    CompressFileHandle *CFH = NULL;
    struct stat st;
    char       *fname;
    pg_compress_specification compression_spec = {0};
 
    compression_spec.algorithm = PG_COMPRESSION_NONE;
 
    Assert(strcmp(mode, PG_BINARY_R) == 0);
 
    fname = pg_strdup(path);
 
    if (hasSuffix(fname, ".gz"))
        compression_spec.algorithm = PG_COMPRESSION_GZIP;
    else if (hasSuffix(fname, ".lz4"))
        compression_spec.algorithm = PG_COMPRESSION_LZ4;
    else if (hasSuffix(fname, ".zst"))
        compression_spec.algorithm = PG_COMPRESSION_ZSTD;
    else
    {
        if (stat(path, &st) == 0)
            compression_spec.algorithm = PG_COMPRESSION_NONE;
        else if (check_compressed_file(path, &fname, "gz"))
            compression_spec.algorithm = PG_COMPRESSION_GZIP;
        else if (check_compressed_file(path, &fname, "lz4"))
            compression_spec.algorithm = PG_COMPRESSION_LZ4;
        else if (check_compressed_file(path, &fname, "zst"))
            compression_spec.algorithm = PG_COMPRESSION_ZSTD;
    }
 
    CFH = InitCompressFileHandle(compression_spec);
    if (!CFH->open_func(fname, -1, mode, CFH))
    {
        free_keep_errno(CFH);
        CFH = NULL;
    }
    free_keep_errno(fname);
 
    return CFH;
}

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.

{
    const pg_compress_algorithm algorithm = compression_spec.algorithm;
    bool        supported = false;
 
    if (algorithm == PG_COMPRESSION_NONE)
        supported = true;
#ifdef HAVE_LIBZ
    if (algorithm == PG_COMPRESSION_GZIP)
        supported = true;
#endif
#ifdef USE_LZ4
    if (algorithm == PG_COMPRESSION_LZ4)
        supported = true;
#endif
#ifdef USE_ZSTD
    if (algorithm == PG_COMPRESSION_ZSTD)
        supported = true;
#endif
 
    if (!supported)
        return psprintf(_("this build does not support compression with %s"),
                        get_compress_algorithm_name(algorithm));
 
    return NULL;
}

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().