Quelle  toast_compression.c

/*-------------------------------------------------------------------------
 *
 * toast_compression.c
 *   Functions for toast compression.
 *
 * Copyright (c) 2021-2025, PostgreSQL Global Development Group
 *
 *
 * IDENTIFICATION
 *   src/backend/access/common/toast_compression.c
 *
 *-------------------------------------------------------------------------
 */
#include "postgres.h"

#ifdef USE_LZ4
#include <lz4.h>
#endif

#include "access/detoast.h"
#include "access/toast_compression.h"
#include "common/pg_lzcompress.h"
#include "varatt.h"

/* GUC */
int   default_toast_compression = TOAST_PGLZ_COMPRESSION;

#define NO_LZ4_SUPPORT() \
 ereport(ERROR, \
   (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), \
    errmsg("compression method lz4 not supported"), \
    errdetail("This functionality requires the server to be built with lz4 support.")))

/*
 * Compress a varlena using PGLZ.
 *
 * Returns the compressed varlena, or NULL if compression fails.
 */
struct varlena *
pglz_compress_datum(const struct varlena *value)
{
 int32  valsize,
    len;
 struct varlena *tmp = NULL;

 valsize = VARSIZE_ANY_EXHDR(value);

 /*
  * No point in wasting a palloc cycle if value size is outside the allowed
  * range for compression.
 */
 if (valsize < PGLZ_strategy_default->min_input_size ||
  valsize > PGLZ_strategy_default->max_input_size)
  return NULL;

 /*
  * Figure out the maximum possible size of the pglz output, add the bytes
  * that will be needed for varlena overhead, and allocate that amount.
 */
 tmp = (struct varlena *) palloc(PGLZ_MAX_OUTPUT(valsize) +
         VARHDRSZ_COMPRESSED);

 len = pglz_compress(VARDATA_ANY(value),
      valsize,
      (char *) tmp + VARHDRSZ_COMPRESSED,
      NULL);
 if (len < 0)
 {
  pfree(tmp);
  return NULL;
 }

 SET_VARSIZE_COMPRESSED(tmp, len + VARHDRSZ_COMPRESSED);

 return tmp;
}

/*
 * Decompress a varlena that was compressed using PGLZ.
 */
struct varlena *
pglz_decompress_datum(const struct varlena *value)
{
 struct varlena *result;
 int32  rawsize;

 /* allocate memory for the uncompressed data */
 result = (struct varlena *) palloc(VARDATA_COMPRESSED_GET_EXTSIZE(value) + VARHDRSZ);

 /* decompress the data */
 rawsize = pglz_decompress((char *) value + VARHDRSZ_COMPRESSED,
         VARSIZE(value) - VARHDRSZ_COMPRESSED,
         VARDATA(result),
         VARDATA_COMPRESSED_GET_EXTSIZE(value), true);
 if (rawsize < 0)
  ereport(ERROR,
    (errcode(ERRCODE_DATA_CORRUPTED),
     errmsg_internal("compressed pglz data is corrupt")));

 SET_VARSIZE(result, rawsize + VARHDRSZ);

 return result;
}

/*
 * Decompress part of a varlena that was compressed using PGLZ.
 */
struct varlena *
pglz_decompress_datum_slice(const struct varlena *value,
       int32 slicelength)
{
 struct varlena *result;
 int32  rawsize;

 /* allocate memory for the uncompressed data */
 result = (struct varlena *) palloc(slicelength + VARHDRSZ);

 /* decompress the data */
 rawsize = pglz_decompress((char *) value + VARHDRSZ_COMPRESSED,
         VARSIZE(value) - VARHDRSZ_COMPRESSED,
         VARDATA(result),
         slicelength, false);
 if (rawsize < 0)
  ereport(ERROR,
    (errcode(ERRCODE_DATA_CORRUPTED),
     errmsg_internal("compressed pglz data is corrupt")));

 SET_VARSIZE(result, rawsize + VARHDRSZ);

 return result;
}

/*
 * Compress a varlena using LZ4.
 *
 * Returns the compressed varlena, or NULL if compression fails.
 */
struct varlena *
lz4_compress_datum(const struct varlena *value)
{
#ifndef USE_LZ4
 NO_LZ4_SUPPORT();
 return NULL;    /* keep compiler quiet */
#else
 int32  valsize;
 int32  len;
 int32  max_size;
 struct varlena *tmp = NULL;

 valsize = VARSIZE_ANY_EXHDR(value);

 /*
  * Figure out the maximum possible size of the LZ4 output, add the bytes
  * that will be needed for varlena overhead, and allocate that amount.
 */
 max_size = LZ4_compressBound(valsize);
 tmp = (struct varlena *) palloc(max_size + VARHDRSZ_COMPRESSED);

 len = LZ4_compress_default(VARDATA_ANY(value),
          (char *) tmp + VARHDRSZ_COMPRESSED,
          valsize, max_size);
 if (len <= 0)
  elog(ERROR, "lz4 compression failed");

 /* data is incompressible so just free the memory and return NULL */
 if (len > valsize)
 {
  pfree(tmp);
  return NULL;
 }

 SET_VARSIZE_COMPRESSED(tmp, len + VARHDRSZ_COMPRESSED);

 return tmp;
#endif
}

/*
 * Decompress a varlena that was compressed using LZ4.
 */
struct varlena *
lz4_decompress_datum(const struct varlena *value)
{
#ifndef USE_LZ4
 NO_LZ4_SUPPORT();
 return NULL;    /* keep compiler quiet */
#else
 int32  rawsize;
 struct varlena *result;

 /* allocate memory for the uncompressed data */
 result = (struct varlena *) palloc(VARDATA_COMPRESSED_GET_EXTSIZE(value) + VARHDRSZ);

 /* decompress the data */
 rawsize = LZ4_decompress_safe((char *) value + VARHDRSZ_COMPRESSED,
          VARDATA(result),
          VARSIZE(value) - VARHDRSZ_COMPRESSED,
          VARDATA_COMPRESSED_GET_EXTSIZE(value));
 if (rawsize < 0)
  ereport(ERROR,
    (errcode(ERRCODE_DATA_CORRUPTED),
     errmsg_internal("compressed lz4 data is corrupt")));


 SET_VARSIZE(result, rawsize + VARHDRSZ);

 return result;
#endif
}

/*
 * Decompress part of a varlena that was compressed using LZ4.
 */
struct varlena *
lz4_decompress_datum_slice(const struct varlena *value, int32 slicelength)
{
#ifndef USE_LZ4
 NO_LZ4_SUPPORT();
 return NULL;    /* keep compiler quiet */
#else
 int32  rawsize;
 struct varlena *result;

 /* slice decompression not supported prior to 1.8.3 */
 if (LZ4_versionNumber() < 10803)
  return lz4_decompress_datum(value);

 /* allocate memory for the uncompressed data */
 result = (struct varlena *) palloc(slicelength + VARHDRSZ);

 /* decompress the data */
 rawsize = LZ4_decompress_safe_partial((char *) value + VARHDRSZ_COMPRESSED,
            VARDATA(result),
            VARSIZE(value) - VARHDRSZ_COMPRESSED,
            slicelength,
            slicelength);
 if (rawsize < 0)
  ereport(ERROR,
    (errcode(ERRCODE_DATA_CORRUPTED),
     errmsg_internal("compressed lz4 data is corrupt")));

 SET_VARSIZE(result, rawsize + VARHDRSZ);

 return result;
#endif
}

/*
 * Extract compression ID from a varlena.
 *
 * Returns TOAST_INVALID_COMPRESSION_ID if the varlena is not compressed.
 */
ToastCompressionId
toast_get_compression_id(struct varlena *attr)
{
 ToastCompressionId cmid = TOAST_INVALID_COMPRESSION_ID;

 /*
  * If it is stored externally then fetch the compression method id from
  * the external toast pointer.  If compressed inline, fetch it from the
  * toast compression header.
 */
 if (VARATT_IS_EXTERNAL_ONDISK(attr))
 {
  struct varatt_external toast_pointer;

  VARATT_EXTERNAL_GET_POINTER(toast_pointer, attr);

  if (VARATT_EXTERNAL_IS_COMPRESSED(toast_pointer))
   cmid = VARATT_EXTERNAL_GET_COMPRESS_METHOD(toast_pointer);
 }
 else if (VARATT_IS_COMPRESSED(attr))
  cmid = VARDATA_COMPRESSED_GET_COMPRESS_METHOD(attr);

 return cmid;
}

/*
 * CompressionNameToMethod - Get compression method from compression name
 *
 * Search in the available built-in methods.  If the compression not found
 * in the built-in methods then return InvalidCompressionMethod.
 */
char
CompressionNameToMethod(const char *compression)
{
 if (strcmp(compression, "pglz") == 0)
  return TOAST_PGLZ_COMPRESSION;
 else if (strcmp(compression, "lz4") == 0)
 {
#ifndef USE_LZ4
  NO_LZ4_SUPPORT();
#endif
  return TOAST_LZ4_COMPRESSION;
 }

 return InvalidCompressionMethod;
}

/*
 * GetCompressionMethodName - Get compression method name
 */
const char *
GetCompressionMethodName(char method)
{
 switch (method)
 {
  case TOAST_PGLZ_COMPRESSION:
   return "pglz";
  case TOAST_LZ4_COMPRESSION:
   return "lz4";
  default:
   elog(ERROR, "invalid compression method %c", method);
   return NULL;  /* keep compiler quiet */
 }
}