bbstreamer.h File Reference

#include "common/compression.h"
#include "lib/stringinfo.h"
#include "pqexpbuffer.h"

Include dependency graph for bbstreamer.h:

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

Go to the source code of this file.

Data Structures
struct	bbstreamer_member
struct	bbstreamer
struct	bbstreamer_ops

Typedefs
typedef struct bbstreamer	bbstreamer
typedef struct bbstreamer_ops	bbstreamer_ops

Enumerations
enum	bbstreamer_archive_context {   BBSTREAMER_UNKNOWN , BBSTREAMER_MEMBER_HEADER , BBSTREAMER_MEMBER_CONTENTS , BBSTREAMER_MEMBER_TRAILER ,   BBSTREAMER_ARCHIVE_TRAILER }

Functions
static void	bbstreamer_content (bbstreamer *streamer, bbstreamer_member *member, const char *data, int len, bbstreamer_archive_context context)
static void	bbstreamer_finalize (bbstreamer *streamer)
static void	bbstreamer_free (bbstreamer *streamer)
static void	bbstreamer_buffer_bytes (bbstreamer *streamer, const char **data, int *len, int nbytes)
static bool	bbstreamer_buffer_until (bbstreamer *streamer, const char **data, int *len, int target_bytes)
bbstreamer *	bbstreamer_plain_writer_new (char *pathname, FILE *file)
bbstreamer *	bbstreamer_gzip_writer_new (char *pathname, FILE *file, pg_compress_specification *compress)
bbstreamer *	bbstreamer_extractor_new (const char *basepath, const char *(*link_map)(const char *), void(*report_output_file)(const char *))
bbstreamer *	bbstreamer_gzip_decompressor_new (bbstreamer *next)
bbstreamer *	bbstreamer_lz4_compressor_new (bbstreamer *next, pg_compress_specification *compress)
bbstreamer *	bbstreamer_lz4_decompressor_new (bbstreamer *next)
bbstreamer *	bbstreamer_zstd_compressor_new (bbstreamer *next, pg_compress_specification *compress)
bbstreamer *	bbstreamer_zstd_decompressor_new (bbstreamer *next)
bbstreamer *	bbstreamer_tar_parser_new (bbstreamer *next)
bbstreamer *	bbstreamer_tar_terminator_new (bbstreamer *next)
bbstreamer *	bbstreamer_tar_archiver_new (bbstreamer *next)
bbstreamer *	bbstreamer_recovery_injector_new (bbstreamer *next, bool is_recovery_guc_supported, PQExpBuffer recoveryconfcontents)
void	bbstreamer_inject_file (bbstreamer *streamer, char *pathname, char *data, int len)

Typedef Documentation

bbstreamer

typedef struct bbstreamer bbstreamer

Definition at line 1 of file bbstreamer.h.

bbstreamer_ops

typedef struct bbstreamer_ops bbstreamer_ops

Definition at line 1 of file bbstreamer.h.

Enumeration Type Documentation

bbstreamer_archive_context

enum bbstreamer_archive_context

Enumerator
BBSTREAMER_UNKNOWN
BBSTREAMER_MEMBER_HEADER
BBSTREAMER_MEMBER_CONTENTS
BBSTREAMER_MEMBER_TRAILER
BBSTREAMER_ARCHIVE_TRAILER

Definition at line 53 of file bbstreamer.h.

{
    BBSTREAMER_UNKNOWN,
    BBSTREAMER_MEMBER_HEADER,
    BBSTREAMER_MEMBER_CONTENTS,
    BBSTREAMER_MEMBER_TRAILER,
    BBSTREAMER_ARCHIVE_TRAILER,
} bbstreamer_archive_context;

Function Documentation

bbstreamer_buffer_bytes()

static void bbstreamer_buffer_bytes ( bbstreamer *  streamer, const char **  data, int *  len, int  nbytes  )

inlinestatic

Definition at line 157 of file bbstreamer.h.

{
    Assert(nbytes <= *len);
 
    appendBinaryStringInfo(&streamer->bbs_buffer, *data, nbytes);
    *len -= nbytes;
    *data += nbytes;
}

References appendBinaryStringInfo(), Assert(), bbstreamer::bbs_buffer, data, and len.

Referenced by bbstreamer_buffer_until(), and bbstreamer_tar_parser_content().

bbstreamer_buffer_until()

static bool bbstreamer_buffer_until ( bbstreamer *  streamer, const char **  data, int *  len, int  target_bytes  )

inlinestatic

Definition at line 175 of file bbstreamer.h.

{
    int         buflen = streamer->bbs_buffer.len;
 
    if (buflen >= target_bytes)
    {
        /* Target length already reached; nothing to do. */
        return true;
    }
 
    if (buflen + *len < target_bytes)
    {
        /* Not enough data to reach target length; buffer all of it. */
        bbstreamer_buffer_bytes(streamer, data, len, *len);
        return false;
    }
 
    /* Buffer just enough to reach the target length. */
    bbstreamer_buffer_bytes(streamer, data, len, target_bytes - buflen);
    return true;
}

References bbstreamer::bbs_buffer, bbstreamer_buffer_bytes(), data, StringInfoData::len, and len.

Referenced by bbstreamer_tar_parser_content().

bbstreamer_content()

static void bbstreamer_content ( bbstreamer *  streamer, bbstreamer_member *  member, const char *  data, int  len, bbstreamer_archive_context  context  )

inlinestatic

Definition at line 126 of file bbstreamer.h.

{
    Assert(streamer != NULL);
    streamer->bbs_ops->content(streamer, member, data, len, context);
}

References Assert(), bbstreamer::bbs_ops, bbstreamer_ops::content, data, and len.

Referenced by bbstreamer_inject_file(), bbstreamer_recovery_injector_content(), bbstreamer_tar_archiver_content(), bbstreamer_tar_header(), bbstreamer_tar_parser_content(), bbstreamer_tar_parser_finalize(), bbstreamer_tar_terminator_content(), bbstreamer_tar_terminator_finalize(), ReceiveArchiveStreamChunk(), and ReceiveTarCopyChunk().

bbstreamer_extractor_new()

bbstreamer* bbstreamer_extractor_new	(	const char *	basepath,
		const char *(*)(const char *)	link_map,
		void(*)(const char *)	report_output_file
	)

Definition at line 183 of file bbstreamer_file.c.

{
    bbstreamer_extractor *streamer;
 
    streamer = palloc0(sizeof(bbstreamer_extractor));
    *((const bbstreamer_ops **) &streamer->base.bbs_ops) =
        &bbstreamer_extractor_ops;
    streamer->basepath = pstrdup(basepath);
    streamer->link_map = link_map;
    streamer->report_output_file = report_output_file;
 
    return &streamer->base;
}

References bbstreamer_extractor::base, bbstreamer_extractor::basepath, bbstreamer::bbs_ops, bbstreamer_extractor_ops, bbstreamer_extractor::link_map, palloc0(), pstrdup(), and bbstreamer_extractor::report_output_file.

Referenced by CreateBackupStreamer().

bbstreamer_finalize()

static void bbstreamer_finalize ( bbstreamer *  streamer )

inlinestatic

Definition at line 136 of file bbstreamer.h.

{
    Assert(streamer != NULL);
    streamer->bbs_ops->finalize(streamer);
}

References Assert(), bbstreamer::bbs_ops, and bbstreamer_ops::finalize.

Referenced by bbstreamer_recovery_injector_finalize(), bbstreamer_tar_archiver_finalize(), bbstreamer_tar_parser_finalize(), bbstreamer_tar_terminator_finalize(), ReceiveArchiveStream(), ReceiveArchiveStreamChunk(), and ReceiveTarFile().

bbstreamer_free()

static void bbstreamer_free ( bbstreamer *  streamer )

inlinestatic

Definition at line 144 of file bbstreamer.h.

{
    Assert(streamer != NULL);
    streamer->bbs_ops->free(streamer);
}

References Assert(), bbstreamer::bbs_ops, and bbstreamer_ops::free.

Referenced by bbstreamer_recovery_injector_free(), bbstreamer_tar_archiver_free(), bbstreamer_tar_parser_free(), bbstreamer_tar_terminator_free(), ReceiveArchiveStream(), ReceiveArchiveStreamChunk(), and ReceiveTarFile().

bbstreamer_gzip_decompressor_new()

bbstreamer* bbstreamer_gzip_decompressor_new

(

bbstreamer *

next

)

Definition at line 212 of file bbstreamer_gzip.c.

{
#ifdef HAVE_LIBZ
    bbstreamer_gzip_decompressor *streamer;
    z_stream   *zs;
 
    Assert(next != NULL);
 
    streamer = palloc0(sizeof(bbstreamer_gzip_decompressor));
    *((const bbstreamer_ops **) &streamer->base.bbs_ops) =
        &bbstreamer_gzip_decompressor_ops;
 
    streamer->base.bbs_next = next;
    initStringInfo(&streamer->base.bbs_buffer);
 
    /* Initialize internal stream state for decompression */
    zs = &streamer->zstream;
    zs->zalloc = gzip_palloc;
    zs->zfree = gzip_pfree;
    zs->next_out = (uint8 *) streamer->base.bbs_buffer.data;
    zs->avail_out = streamer->base.bbs_buffer.maxlen;
 
    /*
     * Data compression was initialized using deflateInit2 to request a gzip
     * header. Similarly, we are using inflateInit2 to initialize data
     * decompression.
     *
     * Per the documentation for inflateInit2, the second argument is
     * "windowBits" and its value must be greater than or equal to the value
     * provided while compressing the data, so we are using the maximum
     * possible value for safety.
     */
    if (inflateInit2(zs, 15 + 16) != Z_OK)
        pg_fatal("could not initialize compression library");
 
    return &streamer->base;
#else
    pg_fatal("this build does not support compression with %s", "gzip");
    return NULL;                /* keep compiler quiet */
#endif
}

References Assert(), if(), initStringInfo(), next, palloc0(), and pg_fatal.

Referenced by CreateBackupStreamer().

bbstreamer_gzip_writer_new()

bbstreamer* bbstreamer_gzip_writer_new	(	char *	pathname,
		FILE *	file,
		pg_compress_specification *	compress
	)

Definition at line 79 of file bbstreamer_gzip.c.

{
#ifdef HAVE_LIBZ
    bbstreamer_gzip_writer *streamer;
 
    streamer = palloc0(sizeof(bbstreamer_gzip_writer));
    *((const bbstreamer_ops **) &streamer->base.bbs_ops) =
        &bbstreamer_gzip_writer_ops;
 
    streamer->pathname = pstrdup(pathname);
 
    if (file == NULL)
    {
        streamer->gzfile = gzopen(pathname, "wb");
        if (streamer->gzfile == NULL)
            pg_fatal("could not create compressed file \"%s\": %m",
                     pathname);
    }
    else
    {
        int         fd = dup(fileno(file));
 
        if (fd < 0)
            pg_fatal("could not duplicate stdout: %m");
 
        streamer->gzfile = gzdopen(fd, "wb");
        if (streamer->gzfile == NULL)
            pg_fatal("could not open output file: %m");
    }
 
    if (gzsetparams(streamer->gzfile, compress->level, Z_DEFAULT_STRATEGY) != Z_OK)
        pg_fatal("could not set compression level %d: %s",
                 compress->level, get_gz_error(streamer->gzfile));
 
    return &streamer->base;
#else
    pg_fatal("this build does not support compression with %s", "gzip");
    return NULL;                /* keep compiler quiet */
#endif
}

References fd(), pg_compress_specification::level, palloc0(), pg_fatal, and pstrdup().

Referenced by CreateBackupStreamer().

bbstreamer_inject_file()

void bbstreamer_inject_file	(	bbstreamer *	streamer,
		char *	pathname,
		char *	data,
		int	len
	)

Definition at line 219 of file bbstreamer_inject.c.

{
    bbstreamer_member member;
 
    strlcpy(member.pathname, pathname, MAXPGPATH);
    member.size = len;
    member.mode = pg_file_create_mode;
    member.is_directory = false;
    member.is_link = false;
    member.linktarget[0] = '\0';
 
    /*
     * There seems to be no principled argument for these values, but they are
     * what PostgreSQL has historically used.
     */
    member.uid = 04000;
    member.gid = 02000;
 
    /*
     * We don't know here how to generate valid member headers and trailers
     * for the archiving format in use, so if those are needed, some successor
     * bbstreamer will have to generate them using the data from 'member'.
     */
    bbstreamer_content(streamer, &member, NULL, 0,
                       BBSTREAMER_MEMBER_HEADER);
    bbstreamer_content(streamer, &member, data, len,
                       BBSTREAMER_MEMBER_CONTENTS);
    bbstreamer_content(streamer, &member, NULL, 0,
                       BBSTREAMER_MEMBER_TRAILER);
}

References bbstreamer_content(), BBSTREAMER_MEMBER_CONTENTS, BBSTREAMER_MEMBER_HEADER, BBSTREAMER_MEMBER_TRAILER, data, bbstreamer_member::gid, bbstreamer_member::is_directory, bbstreamer_member::is_link, len, bbstreamer_member::linktarget, MAXPGPATH, bbstreamer_member::mode, bbstreamer_member::pathname, pg_file_create_mode, bbstreamer_member::size, strlcpy(), and bbstreamer_member::uid.

Referenced by bbstreamer_recovery_injector_content(), ReceiveArchiveStream(), and ReceiveTarFile().

bbstreamer_lz4_compressor_new()

bbstreamer* bbstreamer_lz4_compressor_new	(	bbstreamer *	next,
		pg_compress_specification *	compress
	)

Definition at line 70 of file bbstreamer_lz4.c.

{
#ifdef USE_LZ4
    bbstreamer_lz4_frame *streamer;
    LZ4F_errorCode_t ctxError;
    LZ4F_preferences_t *prefs;
 
    Assert(next != NULL);
 
    streamer = palloc0(sizeof(bbstreamer_lz4_frame));
    *((const bbstreamer_ops **) &streamer->base.bbs_ops) =
        &bbstreamer_lz4_compressor_ops;
 
    streamer->base.bbs_next = next;
    initStringInfo(&streamer->base.bbs_buffer);
    streamer->header_written = false;
 
    /* Initialize stream compression preferences */
    prefs = &streamer->prefs;
    memset(prefs, 0, sizeof(LZ4F_preferences_t));
    prefs->frameInfo.blockSizeID = LZ4F_max256KB;
    prefs->compressionLevel = compress->level;
 
    ctxError = LZ4F_createCompressionContext(&streamer->cctx, LZ4F_VERSION);
    if (LZ4F_isError(ctxError))
        pg_log_error("could not create lz4 compression context: %s",
                     LZ4F_getErrorName(ctxError));
 
    return &streamer->base;
#else
    pg_fatal("this build does not support compression with %s", "LZ4");
    return NULL;                /* keep compiler quiet */
#endif
}

References Assert(), initStringInfo(), pg_compress_specification::level, next, palloc0(), pg_fatal, and pg_log_error.

Referenced by CreateBackupStreamer().

bbstreamer_lz4_decompressor_new()

bbstreamer* bbstreamer_lz4_decompressor_new

(

bbstreamer *

next

)

Definition at line 275 of file bbstreamer_lz4.c.

{
#ifdef USE_LZ4
    bbstreamer_lz4_frame *streamer;
    LZ4F_errorCode_t ctxError;
 
    Assert(next != NULL);
 
    streamer = palloc0(sizeof(bbstreamer_lz4_frame));
    *((const bbstreamer_ops **) &streamer->base.bbs_ops) =
        &bbstreamer_lz4_decompressor_ops;
 
    streamer->base.bbs_next = next;
    initStringInfo(&streamer->base.bbs_buffer);
 
    /* Initialize internal stream state for decompression */
    ctxError = LZ4F_createDecompressionContext(&streamer->dctx, LZ4F_VERSION);
    if (LZ4F_isError(ctxError))
        pg_fatal("could not initialize compression library: %s",
                 LZ4F_getErrorName(ctxError));
 
    return &streamer->base;
#else
    pg_fatal("this build does not support compression with %s", "LZ4");
    return NULL;                /* keep compiler quiet */
#endif
}

References Assert(), initStringInfo(), next, palloc0(), and pg_fatal.

Referenced by CreateBackupStreamer().

bbstreamer_plain_writer_new()

bbstreamer* bbstreamer_plain_writer_new	(	char *	pathname,
		FILE *	file
	)

Definition at line 78 of file bbstreamer_file.c.

{
    bbstreamer_plain_writer *streamer;
 
    streamer = palloc0(sizeof(bbstreamer_plain_writer));
    *((const bbstreamer_ops **) &streamer->base.bbs_ops) =
        &bbstreamer_plain_writer_ops;
 
    streamer->pathname = pstrdup(pathname);
    streamer->file = file;
 
    if (file == NULL)
    {
        streamer->file = fopen(pathname, "wb");
        if (streamer->file == NULL)
            pg_fatal("could not create file \"%s\": %m", pathname);
        streamer->should_close_file = true;
    }
 
    return &streamer->base;
}

References bbstreamer_plain_writer::base, bbstreamer::bbs_ops, bbstreamer_plain_writer_ops, bbstreamer_plain_writer::file, palloc0(), bbstreamer_plain_writer::pathname, pg_fatal, pstrdup(), and bbstreamer_plain_writer::should_close_file.

Referenced by CreateBackupStreamer().

bbstreamer_recovery_injector_new()

bbstreamer* bbstreamer_recovery_injector_new	(	bbstreamer *	next,
		bool	is_recovery_guc_supported,
		PQExpBuffer	recoveryconfcontents
	)

Definition at line 65 of file bbstreamer_inject.c.

{
    bbstreamer_recovery_injector *streamer;
 
    streamer = palloc0(sizeof(bbstreamer_recovery_injector));
    *((const bbstreamer_ops **) &streamer->base.bbs_ops) =
        &bbstreamer_recovery_injector_ops;
    streamer->base.bbs_next = next;
    streamer->is_recovery_guc_supported = is_recovery_guc_supported;
    streamer->recoveryconfcontents = recoveryconfcontents;
 
    return &streamer->base;
}

References bbstreamer_recovery_injector::base, bbstreamer::bbs_next, bbstreamer::bbs_ops, bbstreamer_recovery_injector_ops, bbstreamer_recovery_injector::is_recovery_guc_supported, next, palloc0(), bbstreamer_recovery_injector::recoveryconfcontents, and recoveryconfcontents.

Referenced by CreateBackupStreamer().

bbstreamer_tar_archiver_new()

bbstreamer* bbstreamer_tar_archiver_new

(

bbstreamer *

next

)

Definition at line 356 of file bbstreamer_tar.c.

{
    bbstreamer_tar_archiver *streamer;
 
    streamer = palloc0(sizeof(bbstreamer_tar_archiver));
    *((const bbstreamer_ops **) &streamer->base.bbs_ops) =
        &bbstreamer_tar_archiver_ops;
    streamer->base.bbs_next = next;
 
    return &streamer->base;
}

References bbstreamer_tar_archiver::base, bbstreamer::bbs_next, bbstreamer::bbs_ops, bbstreamer_tar_archiver_ops, next, and palloc0().

Referenced by CreateBackupStreamer().

bbstreamer_tar_parser_new()

bbstreamer* bbstreamer_tar_parser_new

(

bbstreamer *

next

)

Definition at line 93 of file bbstreamer_tar.c.

{
    bbstreamer_tar_parser *streamer;
 
    streamer = palloc0(sizeof(bbstreamer_tar_parser));
    *((const bbstreamer_ops **) &streamer->base.bbs_ops) =
        &bbstreamer_tar_parser_ops;
    streamer->base.bbs_next = next;
    initStringInfo(&streamer->base.bbs_buffer);
    streamer->next_context = BBSTREAMER_MEMBER_HEADER;
 
    return &streamer->base;
}

References bbstreamer_tar_parser::base, bbstreamer::bbs_buffer, bbstreamer::bbs_next, bbstreamer::bbs_ops, BBSTREAMER_MEMBER_HEADER, bbstreamer_tar_parser_ops, initStringInfo(), next, bbstreamer_tar_parser::next_context, and palloc0().

Referenced by CreateBackupStreamer().

bbstreamer_tar_terminator_new()

bbstreamer* bbstreamer_tar_terminator_new

(

bbstreamer *

next

)

Definition at line 462 of file bbstreamer_tar.c.

{
    bbstreamer *streamer;
 
    streamer = palloc0(sizeof(bbstreamer));
    *((const bbstreamer_ops **) &streamer->bbs_ops) =
        &bbstreamer_tar_terminator_ops;
    streamer->bbs_next = next;
 
    return streamer;
}

References bbstreamer::bbs_next, bbstreamer::bbs_ops, bbstreamer_tar_terminator_ops, next, and palloc0().

Referenced by CreateBackupStreamer().

bbstreamer_zstd_compressor_new()

bbstreamer* bbstreamer_zstd_compressor_new	(	bbstreamer *	next,
		pg_compress_specification *	compress
	)

Definition at line 66 of file bbstreamer_zstd.c.

{
#ifdef USE_ZSTD
    bbstreamer_zstd_frame *streamer;
    size_t      ret;
 
    Assert(next != NULL);
 
    streamer = palloc0(sizeof(bbstreamer_zstd_frame));
 
    *((const bbstreamer_ops **) &streamer->base.bbs_ops) =
        &bbstreamer_zstd_compressor_ops;
 
    streamer->base.bbs_next = next;
    initStringInfo(&streamer->base.bbs_buffer);
    enlargeStringInfo(&streamer->base.bbs_buffer, ZSTD_DStreamOutSize());
 
    streamer->cctx = ZSTD_createCCtx();
    if (!streamer->cctx)
        pg_fatal("could not create zstd compression context");
 
    /* Set compression level */
    ret = ZSTD_CCtx_setParameter(streamer->cctx, ZSTD_c_compressionLevel,
                                 compress->level);
    if (ZSTD_isError(ret))
        pg_fatal("could not set zstd compression level to %d: %s",
                 compress->level, ZSTD_getErrorName(ret));
 
    /* Set # of workers, if specified */
    if ((compress->options & PG_COMPRESSION_OPTION_WORKERS) != 0)
    {
        /*
         * On older versions of libzstd, this option does not exist, and
         * trying to set it will fail. Similarly for newer versions if they
         * are compiled without threading support.
         */
        ret = ZSTD_CCtx_setParameter(streamer->cctx, ZSTD_c_nbWorkers,
                                     compress->workers);
        if (ZSTD_isError(ret))
            pg_fatal("could not set compression worker count to %d: %s",
                     compress->workers, ZSTD_getErrorName(ret));
    }
 
    if ((compress->options & PG_COMPRESSION_OPTION_LONG_DISTANCE) != 0)
    {
        ret = ZSTD_CCtx_setParameter(streamer->cctx,
                                     ZSTD_c_enableLongDistanceMatching,
                                     compress->long_distance);
        if (ZSTD_isError(ret))
        {
            pg_log_error("could not enable long-distance mode: %s",
                         ZSTD_getErrorName(ret));
            exit(1);
        }
    }
 
    /* Initialize the ZSTD output buffer. */
    streamer->zstd_outBuf.dst = streamer->base.bbs_buffer.data;
    streamer->zstd_outBuf.size = streamer->base.bbs_buffer.maxlen;
    streamer->zstd_outBuf.pos = 0;
 
    return &streamer->base;
#else
    pg_fatal("this build does not support compression with %s", "ZSTD");
    return NULL;                /* keep compiler quiet */
#endif
}

References Assert(), enlargeStringInfo(), exit(), initStringInfo(), pg_compress_specification::level, pg_compress_specification::long_distance, next, pg_compress_specification::options, palloc0(), PG_COMPRESSION_OPTION_LONG_DISTANCE, PG_COMPRESSION_OPTION_WORKERS, pg_fatal, pg_log_error, and pg_compress_specification::workers.

Referenced by CreateBackupStreamer().

bbstreamer_zstd_decompressor_new()

bbstreamer* bbstreamer_zstd_decompressor_new

(

bbstreamer *

next

)

Definition at line 258 of file bbstreamer_zstd.c.

{
#ifdef USE_ZSTD
    bbstreamer_zstd_frame *streamer;
 
    Assert(next != NULL);
 
    streamer = palloc0(sizeof(bbstreamer_zstd_frame));
    *((const bbstreamer_ops **) &streamer->base.bbs_ops) =
        &bbstreamer_zstd_decompressor_ops;
 
    streamer->base.bbs_next = next;
    initStringInfo(&streamer->base.bbs_buffer);
    enlargeStringInfo(&streamer->base.bbs_buffer, ZSTD_DStreamOutSize());
 
    streamer->dctx = ZSTD_createDCtx();
    if (!streamer->dctx)
        pg_fatal("could not create zstd decompression context");
 
    /* Initialize the ZSTD output buffer. */
    streamer->zstd_outBuf.dst = streamer->base.bbs_buffer.data;
    streamer->zstd_outBuf.size = streamer->base.bbs_buffer.maxlen;
    streamer->zstd_outBuf.pos = 0;
 
    return &streamer->base;
#else
    pg_fatal("this build does not support compression with %s", "ZSTD");
    return NULL;                /* keep compiler quiet */
#endif
}

References Assert(), enlargeStringInfo(), initStringInfo(), next, palloc0(), and pg_fatal.

Referenced by CreateBackupStreamer().