compression.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	pg_compress_specification

Macros
#define	PG_COMPRESSION_OPTION_WORKERS   (1 << 0)
#define	PG_COMPRESSION_OPTION_LONG_DISTANCE   (1 << 1)

Typedefs
typedef enum pg_compress_algorithm	pg_compress_algorithm
typedef struct pg_compress_specification	pg_compress_specification

Enumerations
enum	pg_compress_algorithm { PG_COMPRESSION_NONE , PG_COMPRESSION_GZIP , PG_COMPRESSION_LZ4 , PG_COMPRESSION_ZSTD }

Functions
void	parse_compress_options (const char *option, char **algorithm, char **detail)
bool	parse_compress_algorithm (char *name, pg_compress_algorithm *algorithm)
const char *	get_compress_algorithm_name (pg_compress_algorithm algorithm)
void	parse_compress_specification (pg_compress_algorithm algorithm, char *specification, pg_compress_specification *result)
char *	validate_compress_specification (pg_compress_specification *)

Macro Definition Documentation

PG_COMPRESSION_OPTION_LONG_DISTANCE

#define PG_COMPRESSION_OPTION_LONG_DISTANCE   (1 << 1)

Definition at line 30 of file compression.h.

PG_COMPRESSION_OPTION_WORKERS

#define PG_COMPRESSION_OPTION_WORKERS   (1 << 0)

Definition at line 29 of file compression.h.

Typedef Documentation

pg_compress_algorithm

typedef enum pg_compress_algorithm pg_compress_algorithm

pg_compress_specification

typedef struct pg_compress_specification pg_compress_specification

Enumeration Type Documentation

pg_compress_algorithm

enum pg_compress_algorithm

Enumerator
PG_COMPRESSION_NONE
PG_COMPRESSION_GZIP
PG_COMPRESSION_LZ4
PG_COMPRESSION_ZSTD

Definition at line 21 of file compression.h.

{
    PG_COMPRESSION_NONE,
    PG_COMPRESSION_GZIP,
    PG_COMPRESSION_LZ4,
    PG_COMPRESSION_ZSTD,
} pg_compress_algorithm;

Function Documentation

get_compress_algorithm_name()

const char* get_compress_algorithm_name

(

pg_compress_algorithm

algorithm

)

Definition at line 69 of file compression.c.

{
    switch (algorithm)
    {
        case PG_COMPRESSION_NONE:
            return "none";
        case PG_COMPRESSION_GZIP:
            return "gzip";
        case PG_COMPRESSION_LZ4:
            return "lz4";
        case PG_COMPRESSION_ZSTD:
            return "zstd";
            /* no default, to provoke compiler warnings if values are added */
    }
    Assert(false);
    return "???";               /* placate compiler */
}

References Assert, PG_COMPRESSION_GZIP, PG_COMPRESSION_LZ4, PG_COMPRESSION_NONE, and PG_COMPRESSION_ZSTD.

Referenced by PrintTOCSummary(), supports_compression(), and validate_compress_specification().

parse_compress_algorithm()

bool parse_compress_algorithm	(	char *	name,
		pg_compress_algorithm *	algorithm
	)

Definition at line 49 of file compression.c.

{
    if (strcmp(name, "none") == 0)
        *algorithm = PG_COMPRESSION_NONE;
    else if (strcmp(name, "gzip") == 0)
        *algorithm = PG_COMPRESSION_GZIP;
    else if (strcmp(name, "lz4") == 0)
        *algorithm = PG_COMPRESSION_LZ4;
    else if (strcmp(name, "zstd") == 0)
        *algorithm = PG_COMPRESSION_ZSTD;
    else
        return false;
    return true;
}

References name, PG_COMPRESSION_GZIP, PG_COMPRESSION_LZ4, PG_COMPRESSION_NONE, and PG_COMPRESSION_ZSTD.

Referenced by main(), and parse_basebackup_options().

parse_compress_options()

void parse_compress_options	(	const char *	option,
		char **	algorithm,
		char **	detail
	)

Referenced by backup_parse_compress_options(), and main().

parse_compress_specification()

void parse_compress_specification	(	pg_compress_algorithm	algorithm,
		char *	specification,
		pg_compress_specification *	result
	)

Definition at line 107 of file compression.c.

{
    int         bare_level;
    char       *bare_level_endp;
 
    /* Initial setup of result object. */
    result->algorithm = algorithm;
    result->options = 0;
    result->parse_error = NULL;
 
    /*
     * Assign a default level depending on the compression method.  This may
     * be enforced later.
     */
    switch (result->algorithm)
    {
        case PG_COMPRESSION_NONE:
            result->level = 0;
            break;
        case PG_COMPRESSION_LZ4:
#ifdef USE_LZ4
            result->level = 0;  /* fast compression mode */
#else
            result->parse_error =
                psprintf(_("this build does not support compression with %s"),
                         "LZ4");
#endif
            break;
        case PG_COMPRESSION_ZSTD:
#ifdef USE_ZSTD
            result->level = ZSTD_CLEVEL_DEFAULT;
#else
            result->parse_error =
                psprintf(_("this build does not support compression with %s"),
                         "ZSTD");
#endif
            break;
        case PG_COMPRESSION_GZIP:
#ifdef HAVE_LIBZ
            result->level = Z_DEFAULT_COMPRESSION;
#else
            result->parse_error =
                psprintf(_("this build does not support compression with %s"),
                         "gzip");
#endif
            break;
    }
 
    /* If there is no specification, we're done already. */
    if (specification == NULL)
        return;
 
    /* As a special case, the specification can be a bare integer. */
    bare_level = strtol(specification, &bare_level_endp, 10);
    if (specification != bare_level_endp && *bare_level_endp == '\0')
    {
        result->level = bare_level;
        return;
    }
 
    /* Look for comma-separated keyword or keyword=value entries. */
    while (1)
    {
        char       *kwstart;
        char       *kwend;
        char       *vstart;
        char       *vend;
        int         kwlen;
        int         vlen;
        bool        has_value;
        char       *keyword;
        char       *value;
 
        /* Figure start, end, and length of next keyword and any value. */
        kwstart = kwend = specification;
        while (*kwend != '\0' && *kwend != ',' && *kwend != '=')
            ++kwend;
        kwlen = kwend - kwstart;
        if (*kwend != '=')
        {
            vstart = vend = NULL;
            vlen = 0;
            has_value = false;
        }
        else
        {
            vstart = vend = kwend + 1;
            while (*vend != '\0' && *vend != ',')
                ++vend;
            vlen = vend - vstart;
            has_value = true;
        }
 
        /* Reject empty keyword. */
        if (kwlen == 0)
        {
            result->parse_error =
                pstrdup(_("found empty string where a compression option was expected"));
            break;
        }
 
        /* Extract keyword and value as separate C strings. */
        keyword = palloc(kwlen + 1);
        memcpy(keyword, kwstart, kwlen);
        keyword[kwlen] = '\0';
        if (!has_value)
            value = NULL;
        else
        {
            value = palloc(vlen + 1);
            memcpy(value, vstart, vlen);
            value[vlen] = '\0';
        }
 
        /* Handle whatever keyword we found. */
        if (strcmp(keyword, "level") == 0)
        {
            result->level = expect_integer_value(keyword, value, result);
 
            /*
             * No need to set a flag in "options", there is a default level
             * set at least thanks to the logic above.
             */
        }
        else if (strcmp(keyword, "workers") == 0)
        {
            result->workers = expect_integer_value(keyword, value, result);
            result->options |= PG_COMPRESSION_OPTION_WORKERS;
        }
        else if (strcmp(keyword, "long") == 0)
        {
            result->long_distance = expect_boolean_value(keyword, value, result);
            result->options |= PG_COMPRESSION_OPTION_LONG_DISTANCE;
        }
        else
            result->parse_error =
                psprintf(_("unrecognized compression option: \"%s\""), keyword);
 
        /* Release memory, just to be tidy. */
        pfree(keyword);
        if (value != NULL)
            pfree(value);
 
        /*
         * If we got an error or have reached the end of the string, stop.
         *
         * If there is no value, then the end of the keyword might have been
         * the end of the string. If there is a value, then the end of the
         * keyword cannot have been the end of the string, but the end of the
         * value might have been.
         */
        if (result->parse_error != NULL ||
            (vend == NULL ? *kwend == '\0' : *vend == '\0'))
            break;
 
        /* Advance to next entry and loop around. */
        specification = vend == NULL ? kwend + 1 : vend + 1;
    }
}

References _, pg_compress_specification::algorithm, expect_boolean_value(), expect_integer_value(), pg_compress_specification::level, pg_compress_specification::long_distance, pg_compress_specification::options, palloc(), pg_compress_specification::parse_error, pfree(), PG_COMPRESSION_GZIP, PG_COMPRESSION_LZ4, PG_COMPRESSION_NONE, PG_COMPRESSION_OPTION_LONG_DISTANCE, PG_COMPRESSION_OPTION_WORKERS, PG_COMPRESSION_ZSTD, psprintf(), pstrdup(), value, and pg_compress_specification::workers.

Referenced by main(), and parse_basebackup_options().

validate_compress_specification()

char* validate_compress_specification

(

pg_compress_specification *

spec

)

Definition at line 344 of file compression.c.

{
    int         min_level = 1;
    int         max_level = 1;
    int         default_level = 0;
 
    /* If it didn't even parse OK, it's definitely no good. */
    if (spec->parse_error != NULL)
        return spec->parse_error;
 
    /*
     * Check that the algorithm expects a compression level and it is within
     * the legal range for the algorithm.
     */
    switch (spec->algorithm)
    {
        case PG_COMPRESSION_GZIP:
            max_level = 9;
#ifdef HAVE_LIBZ
            default_level = Z_DEFAULT_COMPRESSION;
#endif
            break;
        case PG_COMPRESSION_LZ4:
            max_level = 12;
            default_level = 0;  /* fast mode */
            break;
        case PG_COMPRESSION_ZSTD:
#ifdef USE_ZSTD
            max_level = ZSTD_maxCLevel();
            min_level = ZSTD_minCLevel();
            default_level = ZSTD_CLEVEL_DEFAULT;
#endif
            break;
        case PG_COMPRESSION_NONE:
            if (spec->level != 0)
                return psprintf(_("compression algorithm \"%s\" does not accept a compression level"),
                                get_compress_algorithm_name(spec->algorithm));
            break;
    }
 
    if ((spec->level < min_level || spec->level > max_level) &&
        spec->level != default_level)
        return psprintf(_("compression algorithm \"%s\" expects a compression level between %d and %d (default at %d)"),
                        get_compress_algorithm_name(spec->algorithm),
                        min_level, max_level, default_level);
 
    /*
     * Of the compression algorithms that we currently support, only zstd
     * allows parallel workers.
     */
    if ((spec->options & PG_COMPRESSION_OPTION_WORKERS) != 0 &&
        (spec->algorithm != PG_COMPRESSION_ZSTD))
    {
        return psprintf(_("compression algorithm \"%s\" does not accept a worker count"),
                        get_compress_algorithm_name(spec->algorithm));
    }
 
    /*
     * Of the compression algorithms that we currently support, only zstd
     * supports long-distance mode.
     */
    if ((spec->options & PG_COMPRESSION_OPTION_LONG_DISTANCE) != 0 &&
        (spec->algorithm != PG_COMPRESSION_ZSTD))
    {
        return psprintf(_("compression algorithm \"%s\" does not support long-distance mode"),
                        get_compress_algorithm_name(spec->algorithm));
    }
 
    return NULL;
}

References _, pg_compress_specification::algorithm, get_compress_algorithm_name(), pg_compress_specification::level, pg_compress_specification::options, pg_compress_specification::parse_error, PG_COMPRESSION_GZIP, PG_COMPRESSION_LZ4, PG_COMPRESSION_NONE, PG_COMPRESSION_OPTION_LONG_DISTANCE, PG_COMPRESSION_OPTION_WORKERS, PG_COMPRESSION_ZSTD, and psprintf().

Referenced by main(), and parse_basebackup_options().