From 2cc0b918b61cc6d231a4c06ad2f2b1d3f2a35583 Mon Sep 17 00:00:00 2001 From: Nikhil Kumar Veldanda Date: Fri, 25 Apr 2025 04:38:01 +0000 Subject: [PATCH 1/2] varattrib_4b design proposal to make it extended to support multiple compression algorithms. --- contrib/amcheck/verify_heapam.c | 3 +- src/backend/access/brin/brin_tuple.c | 4 +- src/backend/access/common/detoast.c | 6 +- src/backend/access/common/indextuple.c | 5 +- src/backend/access/common/toast_compression.c | 26 ++++++- src/backend/access/common/toast_internals.c | 18 +++-- src/backend/access/table/toast_helper.c | 4 +- src/include/access/toast_compression.h | 44 ++++++++--- src/include/access/toast_internals.h | 31 ++++---- src/include/varatt.h | 73 ++++++++++++++++++- src/tools/pgindent/typedefs.list | 2 + 11 files changed, 171 insertions(+), 45 deletions(-) diff --git a/contrib/amcheck/verify_heapam.c b/contrib/amcheck/verify_heapam.c index aa9cccd1da4f..3c3faf595796 100644 --- a/contrib/amcheck/verify_heapam.c +++ b/contrib/amcheck/verify_heapam.c @@ -1786,7 +1786,8 @@ check_tuple_attribute(HeapCheckContext *ctx) bool valid = false; /* Compressed attributes should have a valid compression method */ - cmid = TOAST_COMPRESS_METHOD(&toast_pointer); + cmid = toast_get_compression_id(attr); + switch (cmid) { /* List of all valid compression method IDs */ diff --git a/src/backend/access/brin/brin_tuple.c b/src/backend/access/brin/brin_tuple.c index 861f397e6db5..9c1e22e98c6d 100644 --- a/src/backend/access/brin/brin_tuple.c +++ b/src/backend/access/brin/brin_tuple.c @@ -223,6 +223,7 @@ brin_form_tuple(BrinDesc *brdesc, BlockNumber blkno, BrinMemTuple *tuple, { Datum cvalue; char compression; + CompressionInfo cmp; Form_pg_attribute att = TupleDescAttr(brdesc->bd_tupdesc, keyno); @@ -237,7 +238,8 @@ brin_form_tuple(BrinDesc *brdesc, BlockNumber blkno, BrinMemTuple *tuple, else compression = InvalidCompressionMethod; - cvalue = toast_compress_datum(value, compression); + cmp = setup_compression_info(compression, att); + cvalue = toast_compress_datum(value, cmp); if (DatumGetPointer(cvalue) != NULL) { diff --git a/src/backend/access/common/detoast.c b/src/backend/access/common/detoast.c index 626517877422..01419d1c65f3 100644 --- a/src/backend/access/common/detoast.c +++ b/src/backend/access/common/detoast.c @@ -478,7 +478,7 @@ toast_decompress_datum(struct varlena *attr) * Fetch the compression method id stored in the compression header and * decompress the data using the appropriate decompression routine. */ - cmid = TOAST_COMPRESS_METHOD(attr); + cmid = VARDATA_COMPRESSED_GET_COMPRESS_METHOD(attr); switch (cmid) { case TOAST_PGLZ_COMPRESSION_ID: @@ -514,14 +514,14 @@ toast_decompress_datum_slice(struct varlena *attr, int32 slicelength) * have been seen to give wrong results if passed an output size that is * more than the data's true decompressed size. */ - if ((uint32) slicelength >= TOAST_COMPRESS_EXTSIZE(attr)) + if ((uint32) slicelength >= VARDATA_COMPRESSED_GET_EXTSIZE(attr)) return toast_decompress_datum(attr); /* * Fetch the compression method id stored in the compression header and * decompress the data slice using the appropriate decompression routine. */ - cmid = TOAST_COMPRESS_METHOD(attr); + cmid = VARDATA_COMPRESSED_GET_COMPRESS_METHOD(attr); switch (cmid) { case TOAST_PGLZ_COMPRESSION_ID: diff --git a/src/backend/access/common/indextuple.c b/src/backend/access/common/indextuple.c index 1986b943a28b..0386f5a14910 100644 --- a/src/backend/access/common/indextuple.c +++ b/src/backend/access/common/indextuple.c @@ -123,9 +123,10 @@ index_form_tuple_context(TupleDesc tupleDescriptor, att->attstorage == TYPSTORAGE_MAIN)) { Datum cvalue; + CompressionInfo cmp; - cvalue = toast_compress_datum(untoasted_values[i], - att->attcompression); + cmp = setup_compression_info(att->attcompression, att); + cvalue = toast_compress_datum(untoasted_values[i], cmp); if (DatumGetPointer(cvalue) != NULL) { diff --git a/src/backend/access/common/toast_compression.c b/src/backend/access/common/toast_compression.c index 21f2f4af97e3..de31a8dc5916 100644 --- a/src/backend/access/common/toast_compression.c +++ b/src/backend/access/common/toast_compression.c @@ -266,7 +266,9 @@ toast_get_compression_id(struct varlena *attr) VARATT_EXTERNAL_GET_POINTER(toast_pointer, attr); - if (VARATT_EXTERNAL_IS_COMPRESSED(toast_pointer)) + if (VARATT_EXTERNAL_IS_COMPRESSED(toast_pointer) && VARATT_EXTERNAL_GET_COMPRESS_METHOD(toast_pointer) > TOAST_LAST_COMPRESSION_ID_BEFORE_EXT) + cmid = VARDATA_COMPRESSED_GET_COMPRESS_METHOD(detoast_external_attr(attr)); + else cmid = VARATT_EXTERNAL_GET_COMPRESS_METHOD(toast_pointer); } else if (VARATT_IS_COMPRESSED(attr)) @@ -314,3 +316,25 @@ GetCompressionMethodName(char method) return NULL; /* keep compiler quiet */ } } + +CompressionInfo +setup_compression_info(char cmethod, Form_pg_attribute att) +{ + CompressionInfo info; + + /* initialize from the attribute’s default settings */ + info.cmethod = cmethod; + info.cmp_ext = NULL; + + if (!CompressionMethodIsValid(cmethod)) + info.cmethod = default_toast_compression; + + return info; +} + +void +free_compression_info(CompressionInfo *info) +{ + if (info->cmp_ext != NULL) + pfree(info->cmp_ext); +} diff --git a/src/backend/access/common/toast_internals.c b/src/backend/access/common/toast_internals.c index 7d8be8346ce5..21139f20de3f 100644 --- a/src/backend/access/common/toast_internals.c +++ b/src/backend/access/common/toast_internals.c @@ -43,25 +43,22 @@ static bool toastid_valueid_exists(Oid toastrelid, Oid valueid); * ---------- */ Datum -toast_compress_datum(Datum value, char cmethod) +toast_compress_datum(Datum value, CompressionInfo cmp) { struct varlena *tmp = NULL; int32 valsize; ToastCompressionId cmid = TOAST_INVALID_COMPRESSION_ID; + varatt_cmp_extended *cmp_ext = cmp.cmp_ext; Assert(!VARATT_IS_EXTERNAL(DatumGetPointer(value))); Assert(!VARATT_IS_COMPRESSED(DatumGetPointer(value))); valsize = VARSIZE_ANY_EXHDR(DatumGetPointer(value)); - /* If the compression method is not valid, use the current default */ - if (!CompressionMethodIsValid(cmethod)) - cmethod = default_toast_compression; - /* * Call appropriate compression routine for the compression method. */ - switch (cmethod) + switch (cmp.cmethod) { case TOAST_PGLZ_COMPRESSION: tmp = pglz_compress_datum((const struct varlena *) value); @@ -72,11 +69,14 @@ toast_compress_datum(Datum value, char cmethod) cmid = TOAST_LZ4_COMPRESSION_ID; break; default: - elog(ERROR, "invalid compression method %c", cmethod); + elog(ERROR, "invalid compression method %c", cmp.cmethod); } if (tmp == NULL) + { + free_compression_info(&cmp); return PointerGetDatum(NULL); + } /* * We recheck the actual size even if compression reports success, because @@ -92,13 +92,15 @@ toast_compress_datum(Datum value, char cmethod) { /* successful compression */ Assert(cmid != TOAST_INVALID_COMPRESSION_ID); - TOAST_COMPRESS_SET_SIZE_AND_COMPRESS_METHOD(tmp, valsize, cmid); + TOAST_COMPRESS_SET_SIZE_AND_COMPRESS_METHOD(tmp, valsize, cmid, cmp_ext); + free_compression_info(&cmp); return PointerGetDatum(tmp); } else { /* incompressible data */ pfree(tmp); + free_compression_info(&cmp); return PointerGetDatum(NULL); } } diff --git a/src/backend/access/table/toast_helper.c b/src/backend/access/table/toast_helper.c index b60fab0a4d29..ba5af5db4040 100644 --- a/src/backend/access/table/toast_helper.c +++ b/src/backend/access/table/toast_helper.c @@ -229,8 +229,10 @@ toast_tuple_try_compression(ToastTupleContext *ttc, int attribute) Datum *value = &ttc->ttc_values[attribute]; Datum new_value; ToastAttrInfo *attr = &ttc->ttc_attr[attribute]; + Form_pg_attribute att = TupleDescAttr(ttc->ttc_rel->rd_att, attribute); + CompressionInfo cmp = setup_compression_info(attr->tai_compression, att); - new_value = toast_compress_datum(*value, attr->tai_compression); + new_value = toast_compress_datum(*value, cmp); if (DatumGetPointer(new_value) != NULL) { diff --git a/src/include/access/toast_compression.h b/src/include/access/toast_compression.h index 13c4612ceedc..8e9d5b447523 100644 --- a/src/include/access/toast_compression.h +++ b/src/include/access/toast_compression.h @@ -13,6 +13,10 @@ #ifndef TOAST_COMPRESSION_H #define TOAST_COMPRESSION_H +#include "varatt.h" +#include "toast_compression.h" +#include "catalog/pg_attribute.h" + /* * GUC support. * @@ -23,24 +27,38 @@ extern PGDLLIMPORT int default_toast_compression; /* - * Built-in compression method ID. The toast compression header will store - * this in the first 2 bits of the raw length. These built-in compression - * method IDs are directly mapped to the built-in compression methods. + * TOAST compression methods enumeration. + * + * Each entry defines: + * - NAME : identifier for the compression algorithm + * - VALUE : numeric enum value + * - METADATA type: struct type holding extra info (void when none) * - * Don't use these values for anything other than understanding the meaning - * of the raw bits from a varlena; in particular, if the goal is to identify - * a compression method, use the constants TOAST_PGLZ_COMPRESSION, etc. - * below. We might someday support more than 4 compression methods, but - * we can never have more than 4 values in this enum, because there are - * only 2 bits available in the places where this is stored. + * The INVALID entry is a sentinel and must remain last. */ +#define TOAST_COMPRESSION_LIST \ + X(PGLZ, 0, void) /* PostgreSQL LZ-based */ \ + X(LZ4, 1, void) /* LZ4 algorithm */ \ + X(INVALID, 2, void) /* sentinel, must be last */ + + typedef enum ToastCompressionId { - TOAST_PGLZ_COMPRESSION_ID = 0, - TOAST_LZ4_COMPRESSION_ID = 1, - TOAST_INVALID_COMPRESSION_ID = 2, +#define X(name,val,struct) TOAST_##name##_COMPRESSION_ID = (val), + TOAST_COMPRESSION_LIST +#undef X } ToastCompressionId; +#define TOAST_LAST_COMPRESSION_ID_BEFORE_EXT TOAST_LZ4_COMPRESSION_ID + +typedef struct CompressionInfo +{ + char cmethod; + /* Extended compression meta info */ + varatt_cmp_extended *cmp_ext; +} CompressionInfo; + + /* * Built-in compression methods. pg_attribute will store these in the * attcompression column. In attcompression, InvalidCompressionMethod @@ -69,5 +87,7 @@ extern struct varlena *lz4_decompress_datum_slice(const struct varlena *value, extern ToastCompressionId toast_get_compression_id(struct varlena *attr); extern char CompressionNameToMethod(const char *compression); extern const char *GetCompressionMethodName(char method); +extern CompressionInfo setup_compression_info(char cmethod, Form_pg_attribute att); +extern void free_compression_info(CompressionInfo *info); #endif /* TOAST_COMPRESSION_H */ diff --git a/src/include/access/toast_internals.h b/src/include/access/toast_internals.h index 06ae8583c1e1..e672766f91ae 100644 --- a/src/include/access/toast_internals.h +++ b/src/include/access/toast_internals.h @@ -31,21 +31,26 @@ typedef struct toast_compress_header * Utilities for manipulation of header information for compressed * toast entries. */ -#define TOAST_COMPRESS_EXTSIZE(ptr) \ - (((toast_compress_header *) (ptr))->tcinfo & VARLENA_EXTSIZE_MASK) -#define TOAST_COMPRESS_METHOD(ptr) \ - (((toast_compress_header *) (ptr))->tcinfo >> VARLENA_EXTSIZE_BITS) - -#define TOAST_COMPRESS_SET_SIZE_AND_COMPRESS_METHOD(ptr, len, cm_method) \ - do { \ - Assert((len) > 0 && (len) <= VARLENA_EXTSIZE_MASK); \ - Assert((cm_method) == TOAST_PGLZ_COMPRESSION_ID || \ - (cm_method) == TOAST_LZ4_COMPRESSION_ID); \ - ((toast_compress_header *) (ptr))->tcinfo = \ - (len) | ((uint32) (cm_method) << VARLENA_EXTSIZE_BITS); \ +#define TOAST_COMPRESS_SET_SIZE_AND_COMPRESS_METHOD(ptr, len, cm_method, cmp_ext) \ + do { \ + Assert((len) > 0 && (len) <= VARLENA_EXTSIZE_MASK); \ + Assert((cm_method) == TOAST_PGLZ_COMPRESSION_ID || \ + (cm_method) == TOAST_LZ4_COMPRESSION_ID); \ + if ((cm_method) <= TOAST_LAST_COMPRESSION_ID_BEFORE_EXT) { \ + ((toast_compress_header *) (ptr))->tcinfo = \ + (len) | ((uint32) (cm_method) << VARLENA_EXTSIZE_BITS); \ + } else { \ + /* For compression methods after lz4, use 11 in the top bits of tcinfo \ + to indicate compression algorithm is stored in extended format. */ \ + ((toast_compress_header *) (ptr))->tcinfo = \ + (len) | ((uint32) (VARATT_4BCE_MASK) << VARLENA_EXTSIZE_BITS); \ + Assert((cmp_ext) != NULL); \ + memcpy(VARATT_4BCE_HDR_PTR(ptr), (cmp_ext), \ + sizeof(varatt_cmp_extended) + VARATT_4BCE_META_SIZE( cmp_ext->ext_hdr )); \ + } \ } while (0) -extern Datum toast_compress_datum(Datum value, char cmethod); +extern Datum toast_compress_datum(Datum value, CompressionInfo cmp); extern Oid toast_get_valid_index(Oid toastoid, LOCKMODE lock); extern void toast_delete_datum(Relation rel, Datum value, bool is_speculative); diff --git a/src/include/varatt.h b/src/include/varatt.h index 2e8564d49980..72a49c2322e1 100644 --- a/src/include/varatt.h +++ b/src/include/varatt.h @@ -328,7 +328,8 @@ typedef struct #define VARDATA_COMPRESSED_GET_EXTSIZE(PTR) \ (((varattrib_4b *) (PTR))->va_compressed.va_tcinfo & VARLENA_EXTSIZE_MASK) #define VARDATA_COMPRESSED_GET_COMPRESS_METHOD(PTR) \ - (((varattrib_4b *) (PTR))->va_compressed.va_tcinfo >> VARLENA_EXTSIZE_BITS) + ( (VARATT_IS_4BCE(PTR)) ? (VARATT_4BCE_CMP_METHOD(VARATT_4BCE_HDR_PTR(PTR)->ext_hdr)) \ + : (((varattrib_4b *) (PTR))->va_compressed.va_tcinfo >> VARLENA_EXTSIZE_BITS)) /* Same for external Datums; but note argument is a struct varatt_external */ #define VARATT_EXTERNAL_GET_EXTSIZE(toast_pointer) \ @@ -340,8 +341,17 @@ typedef struct do { \ Assert((cm) == TOAST_PGLZ_COMPRESSION_ID || \ (cm) == TOAST_LZ4_COMPRESSION_ID); \ - ((toast_pointer).va_extinfo = \ - (len) | ((uint32) (cm) << VARLENA_EXTSIZE_BITS)); \ + if ((cm) <= TOAST_LAST_COMPRESSION_ID_BEFORE_EXT) \ + { \ + /* Store the actual method in va_extinfo */ \ + ((toast_pointer).va_extinfo = \ + (len) | ((uint32) (cm) << VARLENA_EXTSIZE_BITS)); \ + } \ + else \ + { \ + /* Store 11 in the top bits, meaning "extended" method. */ \ + (toast_pointer).va_extinfo = (uint32)(len) | (VARATT_4BCE_MASK << VARLENA_EXTSIZE_BITS ); \ + } \ } while (0) /* @@ -355,4 +365,61 @@ typedef struct (VARATT_EXTERNAL_GET_EXTSIZE(toast_pointer) < \ (toast_pointer).va_rawsize - VARHDRSZ) +typedef struct varatt_cmp_extended +{ + uint32 ext_hdr; /* [ size:24 | type:8 ] */ + char ext_data[FLEXIBLE_ARRAY_MEMBER]; /* algorithm-specific meta */ +} varatt_cmp_extended; + +/*--------------------------------------------------------------------*/ +/* 1) Detect the extended compression */ +/* (top-2 mode bits of va_tcinfo are 0b11) */ +#define VARATT_4BCE_MASK 0x0003 + +#define VARATT_IS_4BCE(ptr) \ + ((((varattrib_4b*)(ptr))->va_compressed.va_tcinfo >> VARLENA_EXTSIZE_BITS) \ + == VARATT_4BCE_MASK) + +/*--------------------------------------------------------------------*/ +/* 2) Pointer to varatt_cmp_extended header (just after the 8-byte varlena head) */ +#define VARATT_4BCE_HDR_PTR(ptr) ((varatt_cmp_extended*)(((char*)(ptr)) + VARHDRSZ_COMPRESSED)) +#define VARATT_4BCE_GET_HDR(ptr) ((uint32)(VARATT_4BCE_HDR_PTR(ptr)->ext_hdr)) + +/*--------------------------------------------------------------------*/ +/* 3) The 32-bit ext_hdr */ +/* Layout: [ meta size:24 bits | type:8 bits ] */ +#define VARATT_4BCE_TYPE_MASK 0x000000FF /* low-order 8 bits */ +#define VARATT_4BCE_SIZE_MASK 0xFFFFFF00 /* high-order 24 bits */ + +#define VARATT_4BCE_SET_HDR(hdr, type, size24) \ + do { \ + Assert((uint32)(type) <= VARATT_4BCE_TYPE_MASK); /* 8 bits */ \ + Assert((uint32)(size24) <= (VARATT_4BCE_SIZE_MASK >> 8)); \ + (hdr) = ( ((uint32)(type)) ) | ( ((uint32)(size24) << 8) ); \ + } while (0) + +#define VARATT_4BCE_CMP_METHOD(hdr) ( (uint8) ((hdr) & VARATT_4BCE_TYPE_MASK) ) +#define VARATT_4BCE_META_SIZE(hdr) ( ((hdr) & VARATT_4BCE_SIZE_MASK) >> 8) + +/*--------------------------------------------------------------------*/ +/* 4) Derived helpers to jump inside the extension block */ + +/* -> metadata begins immediately after the 4-byte ext header */ +#define VARATT_4BCE_META_PTR(ptr) ( (void*) VARATT_4BCE_HDR_PTR(ptr)->ext_data ) + +/* -> compressed bytes begins after metadata */ +#define VARATT_4BCE_DATA_PTR(ptr) \ + ( (void*)( (char*)VARATT_4BCE_META_PTR(ptr) \ + + VARATT_4BCE_META_SIZE(VARATT_4BCE_HDR_PTR(ptr)->ext_hdr) ) ) + +/* -> payload byte count */ +#define VARATT_4BCE_DATA_SIZE(ptr) \ + ( VARSIZE_4B(ptr) \ + - VARHDRSZ_COMPRESSED \ + - sizeof(varatt_cmp_extended) \ + - VARATT_4BCE_META_SIZE(VARATT_4BCE_HDR_PTR(ptr)->ext_hdr) ) + +/* Expects varatt_cmp_extended pointer */ +#define VARATT_4BCE_HDRSZ(ptr) (VARHDRSZ_COMPRESSED + sizeof(varatt_cmp_extended) + VARATT_4BCE_META_SIZE((ptr)->ext_hdr)) + #endif diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index e5879e00dffe..ea28675e0c97 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -482,6 +482,7 @@ CompositeIOData CompositeTypeStmt CompoundAffixFlag CompressFileHandle +CompressionInfo CompressionLocation CompressorState ComputeXidHorizonsResult @@ -4153,6 +4154,7 @@ uuid_t va_list vacuumingOptions validate_string_relopt +varatt_cmp_extended varatt_expanded varattrib_1b varattrib_1b_e From 465f41ae65e962f597c3badbc38f915de1a46028 Mon Sep 17 00:00:00 2001 From: Nikhil Kumar Veldanda Date: Fri, 25 Apr 2025 06:00:37 +0000 Subject: [PATCH 2/2] zstd nodict support. --- contrib/amcheck/verify_heapam.c | 1 + src/backend/access/common/detoast.c | 12 +- src/backend/access/common/reloptions.c | 14 +- src/backend/access/common/toast_compression.c | 223 +++++++++++++++++- src/backend/access/common/toast_internals.c | 4 + src/backend/utils/adt/varlena.c | 3 + src/backend/utils/misc/guc_tables.c | 3 + src/backend/utils/misc/postgresql.conf.sample | 2 +- src/bin/psql/describe.c | 5 +- src/bin/psql/tab-complete.in.c | 4 +- src/include/access/toast_compression.h | 31 ++- src/include/access/toast_internals.h | 3 +- src/include/utils/attoptcache.h | 1 + src/include/varatt.h | 3 +- src/test/regress/expected/compression.out | 5 +- src/test/regress/expected/compression_1.out | 3 + src/test/regress/sql/compression.sql | 1 + 17 files changed, 292 insertions(+), 26 deletions(-) diff --git a/contrib/amcheck/verify_heapam.c b/contrib/amcheck/verify_heapam.c index 3c3faf595796..f1b7e77a322d 100644 --- a/contrib/amcheck/verify_heapam.c +++ b/contrib/amcheck/verify_heapam.c @@ -1793,6 +1793,7 @@ check_tuple_attribute(HeapCheckContext *ctx) /* List of all valid compression method IDs */ case TOAST_PGLZ_COMPRESSION_ID: case TOAST_LZ4_COMPRESSION_ID: + case TOAST_ZSTD_NODICT_COMPRESSION_ID: valid = true; break; diff --git a/src/backend/access/common/detoast.c b/src/backend/access/common/detoast.c index 01419d1c65f3..72b0a2c5672d 100644 --- a/src/backend/access/common/detoast.c +++ b/src/backend/access/common/detoast.c @@ -246,10 +246,10 @@ detoast_attr_slice(struct varlena *attr, * Determine maximum amount of compressed data needed for a prefix * of a given length (after decompression). * - * At least for now, if it's LZ4 data, we'll have to fetch the - * whole thing, because there doesn't seem to be an API call to - * determine how much compressed data we need to be sure of being - * able to decompress the required slice. + * At least for now, if it's LZ4 or Zstandard data, we'll have to + * fetch the whole thing, because there doesn't seem to be an API + * call to determine how much compressed data we need to be sure + * of being able to decompress the required slice. */ if (VARATT_EXTERNAL_GET_COMPRESS_METHOD(toast_pointer) == TOAST_PGLZ_COMPRESSION_ID) @@ -485,6 +485,8 @@ toast_decompress_datum(struct varlena *attr) return pglz_decompress_datum(attr); case TOAST_LZ4_COMPRESSION_ID: return lz4_decompress_datum(attr); + case TOAST_ZSTD_NODICT_COMPRESSION_ID: + return zstd_decompress_datum(attr); default: elog(ERROR, "invalid compression method id %d", cmid); return NULL; /* keep compiler quiet */ @@ -528,6 +530,8 @@ toast_decompress_datum_slice(struct varlena *attr, int32 slicelength) return pglz_decompress_datum_slice(attr, slicelength); case TOAST_LZ4_COMPRESSION_ID: return lz4_decompress_datum_slice(attr, slicelength); + case TOAST_ZSTD_NODICT_COMPRESSION_ID: + return zstd_decompress_datum_slice(attr, slicelength); default: elog(ERROR, "invalid compression method id %d", cmid); return NULL; /* keep compiler quiet */ diff --git a/src/backend/access/common/reloptions.c b/src/backend/access/common/reloptions.c index 46c1dce222d1..1267668a2424 100644 --- a/src/backend/access/common/reloptions.c +++ b/src/backend/access/common/reloptions.c @@ -24,6 +24,7 @@ #include "access/nbtree.h" #include "access/reloptions.h" #include "access/spgist_private.h" +#include "access/toast_compression.h" #include "catalog/pg_type.h" #include "commands/defrem.h" #include "commands/tablespace.h" @@ -381,7 +382,15 @@ static relopt_int intRelOpts[] = }, -1, 0, 1024 }, - + { + { + "zstd_level", + "Set column's ZSTD compression level", + RELOPT_KIND_ATTRIBUTE, + ShareUpdateExclusiveLock + }, + DEFAULT_ZSTD_LEVEL, MIN_ZSTD_LEVEL, MAX_ZSTD_LEVEL + }, /* list terminator */ {{NULL}} }; @@ -2097,7 +2106,8 @@ attribute_reloptions(Datum reloptions, bool validate) { static const relopt_parse_elt tab[] = { {"n_distinct", RELOPT_TYPE_REAL, offsetof(AttributeOpts, n_distinct)}, - {"n_distinct_inherited", RELOPT_TYPE_REAL, offsetof(AttributeOpts, n_distinct_inherited)} + {"n_distinct_inherited", RELOPT_TYPE_REAL, offsetof(AttributeOpts, n_distinct_inherited)}, + {"zstd_level", RELOPT_TYPE_INT, offsetof(AttributeOpts, zstd_level)}, }; return (bytea *) build_reloptions(reloptions, validate, diff --git a/src/backend/access/common/toast_compression.c b/src/backend/access/common/toast_compression.c index de31a8dc5916..ec1bbffaaf0a 100644 --- a/src/backend/access/common/toast_compression.c +++ b/src/backend/access/common/toast_compression.c @@ -17,19 +17,36 @@ #include #endif +#ifdef USE_ZSTD +#include +#endif + #include "access/detoast.h" #include "access/toast_compression.h" #include "common/pg_lzcompress.h" #include "varatt.h" +#include "utils/attoptcache.h" /* GUC */ int default_toast_compression = TOAST_PGLZ_COMPRESSION; -#define NO_LZ4_SUPPORT() \ +#ifdef USE_ZSTD +static ZSTD_CCtx *ZstdCompressionCtx = NULL; + +static ZSTD_DCtx *ZstdDecompressionCtx = NULL; + +#define ZSTD_CHECK_ERROR(zstd_ret, msg) \ + do { \ + if (ZSTD_isError(zstd_ret)) \ + ereport(ERROR, (errmsg("%s: %s", (msg), ZSTD_getErrorName(zstd_ret)))); \ + } while (0) +#endif + +#define COMPRESSION_METHOD_NOT_SUPPORTED(method) \ 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."))) + errmsg("compression method %s not supported", method), \ + errdetail("This functionality requires the server to be built with %s support.", method))) /* * Compress a varlena using PGLZ. @@ -139,7 +156,7 @@ struct varlena * lz4_compress_datum(const struct varlena *value) { #ifndef USE_LZ4 - NO_LZ4_SUPPORT(); + COMPRESSION_METHOD_NOT_SUPPORTED("lz4"); return NULL; /* keep compiler quiet */ #else int32 valsize; @@ -182,7 +199,7 @@ struct varlena * lz4_decompress_datum(const struct varlena *value) { #ifndef USE_LZ4 - NO_LZ4_SUPPORT(); + COMPRESSION_METHOD_NOT_SUPPORTED("lz4"); return NULL; /* keep compiler quiet */ #else int32 rawsize; @@ -215,7 +232,7 @@ struct varlena * lz4_decompress_datum_slice(const struct varlena *value, int32 slicelength) { #ifndef USE_LZ4 - NO_LZ4_SUPPORT(); + COMPRESSION_METHOD_NOT_SUPPORTED("lz4"); return NULL; /* keep compiler quiet */ #else int32 rawsize; @@ -245,6 +262,167 @@ lz4_decompress_datum_slice(const struct varlena *value, int32 slicelength) #endif } +/* Compress datum using ZSTD with optional dictionary (using cdict) */ +struct varlena * +zstd_compress_datum(const struct varlena *value, CompressionInfo cmp) +{ +#ifdef USE_ZSTD + uint32 valsize = VARSIZE_ANY_EXHDR(value); + size_t max_size = ZSTD_compressBound(valsize); + struct varlena *compressed; + void *dest; + size_t cmp_size, + ret; + + /* Create the session CCtx if it hasn't been yet */ + if (ZstdCompressionCtx == NULL) + { + ZstdCompressionCtx = ZSTD_createCCtx(); + if (!ZstdCompressionCtx) + ereport(ERROR, (errmsg("could not create ZSTD_CCtx"))); + } + + /* Reset the context to clear any prior state */ + ret = ZSTD_CCtx_reset(ZstdCompressionCtx, ZSTD_reset_session_only); + ZSTD_CHECK_ERROR(ret, "failed to reset ZSTD CCtx"); + + /* Set compression level */ + ret = ZSTD_CCtx_setParameter(ZstdCompressionCtx, ZSTD_c_compressionLevel, cmp.zstd_level); + ZSTD_CHECK_ERROR(ret, "failed to set ZSTD compression level"); + + /* Allocate space for the compressed varlena (header + data) */ + compressed = (struct varlena *) palloc(max_size + VARATT_4BCE_HDRSZ(cmp.cmp_ext)); + dest = (char *) compressed + VARATT_4BCE_HDRSZ(cmp.cmp_ext); + + cmp_size = ZSTD_compress2(ZstdCompressionCtx, + dest, + max_size, + VARDATA_ANY(value), + valsize); + + if (ZSTD_isError(cmp_size)) + { + pfree(compressed); + ZSTD_CHECK_ERROR(cmp_size, "ZSTD compression failed"); + } + + /* + * If compression did not reduce size, return NULL so that the + * uncompressed data is stored + */ + if (cmp_size > valsize) + { + pfree(compressed); + return NULL; + } + + /* Set the compressed size in the varlena header */ + SET_VARSIZE_COMPRESSED(compressed, cmp_size + VARATT_4BCE_HDRSZ(cmp.cmp_ext)); + return compressed; + +#else + COMPRESSION_METHOD_NOT_SUPPORTED("zstd_nodict"); + return NULL; +#endif +} + +/* Decompression routine */ +struct varlena * +zstd_decompress_datum(const struct varlena *value) +{ +#ifdef USE_ZSTD + uint32 actual_size_exhdr = VARDATA_COMPRESSED_GET_EXTSIZE(value); + uint32 cmp_size_exhdr = VARATT_4BCE_DATA_SIZE(value); + struct varlena *result; + size_t uncmp_size, + ret; + + if (ZstdDecompressionCtx == NULL) + { + ZstdDecompressionCtx = ZSTD_createDCtx(); + if (!ZstdDecompressionCtx) + ereport(ERROR, (errmsg("could not create ZSTD_DCtx"))); + } + + /* Reset the context to clear any prior state */ + ret = ZSTD_DCtx_reset(ZstdDecompressionCtx, ZSTD_reset_session_only); + ZSTD_CHECK_ERROR(ret, "failed to reset ZSTD DCtx"); + + /* Allocate space for the uncompressed data */ + result = (struct varlena *) palloc(actual_size_exhdr + VARHDRSZ); + + uncmp_size = ZSTD_decompressDCtx(ZstdDecompressionCtx, + VARDATA(result), + actual_size_exhdr, + VARATT_4BCE_DATA_PTR(value), + cmp_size_exhdr); + + if (ZSTD_isError(uncmp_size)) + { + pfree(result); + ZSTD_CHECK_ERROR(uncmp_size, "ZSTD decompression failed"); + } + + /* Set final size in the varlena header */ + SET_VARSIZE(result, uncmp_size + VARHDRSZ); + return result; + +#else + COMPRESSION_METHOD_NOT_SUPPORTED("zstd_nodict"); + return NULL; +#endif +} + +/* Decompress a slice of the datum using the streaming API and optional dictionary */ +struct varlena * +zstd_decompress_datum_slice(const struct varlena *value, int32 slicelength) +{ +#ifdef USE_ZSTD + struct varlena *result; + ZSTD_inBuffer inBuf; + ZSTD_outBuffer outBuf; + size_t ret; + + if (ZstdDecompressionCtx == NULL) + { + ZstdDecompressionCtx = ZSTD_createDCtx(); + if (!ZstdDecompressionCtx) + elog(ERROR, "could not create ZSTD_DCtx"); + } + + /* Reset the context to clear any prior state */ + ret = ZSTD_DCtx_reset(ZstdDecompressionCtx, ZSTD_reset_session_only); + ZSTD_CHECK_ERROR(ret, "failed to reset ZSTD_DCtx"); + + inBuf.src = VARATT_4BCE_DATA_PTR(value); + inBuf.size = VARATT_4BCE_DATA_SIZE(value); + inBuf.pos = 0; + + result = (struct varlena *) palloc(slicelength + VARHDRSZ); + outBuf.dst = (char *) result + VARHDRSZ; + outBuf.size = slicelength; + outBuf.pos = 0; + + /* Common decompression loop */ + while (inBuf.pos < inBuf.size && outBuf.pos < outBuf.size) + { + ret = ZSTD_decompressStream(ZstdDecompressionCtx, &outBuf, &inBuf); + if (ZSTD_isError(ret)) + { + pfree(result); + ZSTD_CHECK_ERROR(ret, "zstd decompression failed"); + } + } + + Assert(outBuf.size == slicelength && outBuf.pos == slicelength); + SET_VARSIZE(result, outBuf.pos + VARHDRSZ); + return result; +#else + COMPRESSION_METHOD_NOT_SUPPORTED("zstd_nodict"); + return NULL; +#endif +} + /* * Extract compression ID from a varlena. * @@ -291,10 +469,17 @@ CompressionNameToMethod(const char *compression) else if (strcmp(compression, "lz4") == 0) { #ifndef USE_LZ4 - NO_LZ4_SUPPORT(); + COMPRESSION_METHOD_NOT_SUPPORTED("lz4"); #endif return TOAST_LZ4_COMPRESSION; } + else if (strcmp(compression, "zstd_nodict") == 0) + { +#ifndef USE_ZSTD + COMPRESSION_METHOD_NOT_SUPPORTED("zstd_nodict"); +#endif + return TOAST_ZSTD_NODICT_COMPRESSION; + } return InvalidCompressionMethod; } @@ -311,6 +496,8 @@ GetCompressionMethodName(char method) return "pglz"; case TOAST_LZ4_COMPRESSION: return "lz4"; + case TOAST_ZSTD_NODICT_COMPRESSION: + return "zstd_nodict"; default: elog(ERROR, "invalid compression method %c", method); return NULL; /* keep compiler quiet */ @@ -324,11 +511,33 @@ setup_compression_info(char cmethod, Form_pg_attribute att) /* initialize from the attribute’s default settings */ info.cmethod = cmethod; + info.zstd_level = DEFAULT_ZSTD_LEVEL; info.cmp_ext = NULL; if (!CompressionMethodIsValid(cmethod)) info.cmethod = default_toast_compression; + switch (info.cmethod) + { + case TOAST_PGLZ_COMPRESSION: + case TOAST_LZ4_COMPRESSION: + break; + case TOAST_ZSTD_NODICT_COMPRESSION: + { + AttributeOpts *aopt = get_attribute_options(att->attrelid, att->attnum); + + if (aopt != NULL) + info.zstd_level = aopt->zstd_level; + + info.cmp_ext = palloc(sizeof(varatt_cmp_extended)); + + VARATT_4BCE_SET_HDR(info.cmp_ext->ext_hdr, TOAST_ZSTD_NODICT_COMPRESSION_ID, 0); + } + break; + default: + elog(ERROR, "invalid compression method %c", info.cmethod); + } + return info; } diff --git a/src/backend/access/common/toast_internals.c b/src/backend/access/common/toast_internals.c index 21139f20de3f..7cc2c2bf8ac1 100644 --- a/src/backend/access/common/toast_internals.c +++ b/src/backend/access/common/toast_internals.c @@ -68,6 +68,10 @@ toast_compress_datum(Datum value, CompressionInfo cmp) tmp = lz4_compress_datum((const struct varlena *) value); cmid = TOAST_LZ4_COMPRESSION_ID; break; + case TOAST_ZSTD_NODICT_COMPRESSION: + tmp = zstd_compress_datum((const struct varlena *) value, cmp); + cmid = TOAST_ZSTD_NODICT_COMPRESSION_ID; + break; default: elog(ERROR, "invalid compression method %c", cmp.cmethod); } diff --git a/src/backend/utils/adt/varlena.c b/src/backend/utils/adt/varlena.c index 3e4d5568bde8..5b9151c7e161 100644 --- a/src/backend/utils/adt/varlena.c +++ b/src/backend/utils/adt/varlena.c @@ -5301,6 +5301,9 @@ pg_column_compression(PG_FUNCTION_ARGS) case TOAST_LZ4_COMPRESSION_ID: result = "lz4"; break; + case TOAST_ZSTD_NODICT_COMPRESSION_ID: + result = "zstd_nodict"; + break; default: elog(ERROR, "invalid compression method id %d", cmid); } diff --git a/src/backend/utils/misc/guc_tables.c b/src/backend/utils/misc/guc_tables.c index 2f8cbd867599..948454e20939 100644 --- a/src/backend/utils/misc/guc_tables.c +++ b/src/backend/utils/misc/guc_tables.c @@ -460,6 +460,9 @@ static const struct config_enum_entry default_toast_compression_options[] = { {"pglz", TOAST_PGLZ_COMPRESSION, false}, #ifdef USE_LZ4 {"lz4", TOAST_LZ4_COMPRESSION, false}, +#endif +#ifdef USE_ZSTD + {"zstd_nodict", TOAST_ZSTD_NODICT_COMPRESSION, false}, #endif {NULL, 0, false} }; diff --git a/src/backend/utils/misc/postgresql.conf.sample b/src/backend/utils/misc/postgresql.conf.sample index 34826d01380b..f2d2ca395143 100644 --- a/src/backend/utils/misc/postgresql.conf.sample +++ b/src/backend/utils/misc/postgresql.conf.sample @@ -756,7 +756,7 @@ autovacuum_worker_slots = 16 # autovacuum worker slots to allocate #row_security = on #default_table_access_method = 'heap' #default_tablespace = '' # a tablespace name, '' uses the default -#default_toast_compression = 'pglz' # 'pglz' or 'lz4' +#default_toast_compression = 'pglz' # 'pglz' or 'lz4' or 'zstd_nodict' #temp_tablespaces = '' # a list of tablespace names, '' uses # only default tablespace #check_function_bodies = on diff --git a/src/bin/psql/describe.c b/src/bin/psql/describe.c index 1d08268393e3..3831a7fab034 100644 --- a/src/bin/psql/describe.c +++ b/src/bin/psql/describe.c @@ -2171,8 +2171,9 @@ describeOneTableDetails(const char *schemaname, /* these strings are literal in our syntax, so not translated. */ printTableAddCell(&cont, (compression[0] == 'p' ? "pglz" : (compression[0] == 'l' ? "lz4" : - (compression[0] == '\0' ? "" : - "???"))), + (compression[0] == 'n' ? "zstd_nodict" : + (compression[0] == '\0' ? "" : + "???")))), false, false); } diff --git a/src/bin/psql/tab-complete.in.c b/src/bin/psql/tab-complete.in.c index c916b9299a80..2441acf41cea 100644 --- a/src/bin/psql/tab-complete.in.c +++ b/src/bin/psql/tab-complete.in.c @@ -2875,11 +2875,11 @@ match_previous_words(int pattern_id, /* ALTER TABLE ALTER [COLUMN] SET ( */ else if (Matches("ALTER", "TABLE", MatchAny, "ALTER", "COLUMN", MatchAny, "SET", "(") || Matches("ALTER", "TABLE", MatchAny, "ALTER", MatchAny, "SET", "(")) - COMPLETE_WITH("n_distinct", "n_distinct_inherited"); + COMPLETE_WITH("n_distinct", "n_distinct_inherited", "zstd_level"); /* ALTER TABLE ALTER [COLUMN] SET COMPRESSION */ else if (Matches("ALTER", "TABLE", MatchAny, "ALTER", "COLUMN", MatchAny, "SET", "COMPRESSION") || Matches("ALTER", "TABLE", MatchAny, "ALTER", MatchAny, "SET", "COMPRESSION")) - COMPLETE_WITH("DEFAULT", "PGLZ", "LZ4"); + COMPLETE_WITH("DEFAULT", "PGLZ", "LZ4", "ZSTD_NODICT"); /* ALTER TABLE ALTER [COLUMN] SET EXPRESSION */ else if (Matches("ALTER", "TABLE", MatchAny, "ALTER", "COLUMN", MatchAny, "SET", "EXPRESSION") || Matches("ALTER", "TABLE", MatchAny, "ALTER", MatchAny, "SET", "EXPRESSION")) diff --git a/src/include/access/toast_compression.h b/src/include/access/toast_compression.h index 8e9d5b447523..9af4a14ebed8 100644 --- a/src/include/access/toast_compression.h +++ b/src/include/access/toast_compression.h @@ -17,6 +17,10 @@ #include "toast_compression.h" #include "catalog/pg_attribute.h" +#ifdef USE_ZSTD +#include +#endif + /* * GUC support. * @@ -36,10 +40,11 @@ extern PGDLLIMPORT int default_toast_compression; * * The INVALID entry is a sentinel and must remain last. */ -#define TOAST_COMPRESSION_LIST \ - X(PGLZ, 0, void) /* PostgreSQL LZ-based */ \ - X(LZ4, 1, void) /* LZ4 algorithm */ \ - X(INVALID, 2, void) /* sentinel, must be last */ +#define TOAST_COMPRESSION_LIST \ + X(PGLZ, 0, void) /* PostgreSQL LZ-based */ \ + X(LZ4, 1, void) /* LZ4 algorithm */ \ + X(ZSTD_NODICT, 2, void) /* ZSTD algorithm, no dictionary */ \ + X(INVALID, 3, void) /* sentinel, must be last */ typedef enum ToastCompressionId @@ -54,6 +59,7 @@ typedef enum ToastCompressionId typedef struct CompressionInfo { char cmethod; + int zstd_level; /* Extended compression meta info */ varatt_cmp_extended *cmp_ext; } CompressionInfo; @@ -66,10 +72,22 @@ typedef struct CompressionInfo */ #define TOAST_PGLZ_COMPRESSION 'p' #define TOAST_LZ4_COMPRESSION 'l' +#define TOAST_ZSTD_NODICT_COMPRESSION 'n' #define InvalidCompressionMethod '\0' #define CompressionMethodIsValid(cm) ((cm) != InvalidCompressionMethod) +#define InvalidDictId 0 + +#ifdef USE_ZSTD +#define DEFAULT_ZSTD_LEVEL ZSTD_CLEVEL_DEFAULT +#define MIN_ZSTD_LEVEL (int)-ZSTD_BLOCKSIZE_MAX +#define MAX_ZSTD_LEVEL 22 +#else +#define DEFAULT_ZSTD_LEVEL 0 +#define MIN_ZSTD_LEVEL 0 +#define MAX_ZSTD_LEVEL 0 +#endif /* pglz compression/decompression routines */ extern struct varlena *pglz_compress_datum(const struct varlena *value); @@ -83,6 +101,11 @@ extern struct varlena *lz4_decompress_datum(const struct varlena *value); extern struct varlena *lz4_decompress_datum_slice(const struct varlena *value, int32 slicelength); +/* zstd compression/decompression routines */ +extern struct varlena *zstd_compress_datum(const struct varlena *value, CompressionInfo cmp); +extern struct varlena *zstd_decompress_datum(const struct varlena *value); +extern struct varlena *zstd_decompress_datum_slice(const struct varlena *value, int32 slicelength); + /* other stuff */ extern ToastCompressionId toast_get_compression_id(struct varlena *attr); extern char CompressionNameToMethod(const char *compression); diff --git a/src/include/access/toast_internals.h b/src/include/access/toast_internals.h index e672766f91ae..7ae69792596d 100644 --- a/src/include/access/toast_internals.h +++ b/src/include/access/toast_internals.h @@ -35,7 +35,8 @@ typedef struct toast_compress_header do { \ Assert((len) > 0 && (len) <= VARLENA_EXTSIZE_MASK); \ Assert((cm_method) == TOAST_PGLZ_COMPRESSION_ID || \ - (cm_method) == TOAST_LZ4_COMPRESSION_ID); \ + (cm_method) == TOAST_LZ4_COMPRESSION_ID || \ + (cm_method) == TOAST_ZSTD_NODICT_COMPRESSION_ID); \ if ((cm_method) <= TOAST_LAST_COMPRESSION_ID_BEFORE_EXT) { \ ((toast_compress_header *) (ptr))->tcinfo = \ (len) | ((uint32) (cm_method) << VARLENA_EXTSIZE_BITS); \ diff --git a/src/include/utils/attoptcache.h b/src/include/utils/attoptcache.h index f684a772af52..51d65ebd6461 100644 --- a/src/include/utils/attoptcache.h +++ b/src/include/utils/attoptcache.h @@ -21,6 +21,7 @@ typedef struct AttributeOpts int32 vl_len_; /* varlena header (do not touch directly!) */ float8 n_distinct; float8 n_distinct_inherited; + int zstd_level; } AttributeOpts; extern AttributeOpts *get_attribute_options(Oid attrelid, int attnum); diff --git a/src/include/varatt.h b/src/include/varatt.h index 72a49c2322e1..4e60706744b3 100644 --- a/src/include/varatt.h +++ b/src/include/varatt.h @@ -340,7 +340,8 @@ typedef struct #define VARATT_EXTERNAL_SET_SIZE_AND_COMPRESS_METHOD(toast_pointer, len, cm) \ do { \ Assert((cm) == TOAST_PGLZ_COMPRESSION_ID || \ - (cm) == TOAST_LZ4_COMPRESSION_ID); \ + (cm) == TOAST_LZ4_COMPRESSION_ID || \ + (cm) == TOAST_ZSTD_NODICT_COMPRESSION_ID); \ if ((cm) <= TOAST_LAST_COMPRESSION_ID_BEFORE_EXT) \ { \ /* Store the actual method in va_extinfo */ \ diff --git a/src/test/regress/expected/compression.out b/src/test/regress/expected/compression.out index 4dd9ee7200d1..c7e108a0f521 100644 --- a/src/test/regress/expected/compression.out +++ b/src/test/regress/expected/compression.out @@ -238,10 +238,11 @@ NOTICE: merging multiple inherited definitions of column "f1" -- test default_toast_compression GUC SET default_toast_compression = ''; ERROR: invalid value for parameter "default_toast_compression": "" -HINT: Available values: pglz, lz4. +HINT: Available values: pglz, lz4, zstd_nodict. SET default_toast_compression = 'I do not exist compression'; ERROR: invalid value for parameter "default_toast_compression": "I do not exist compression" -HINT: Available values: pglz, lz4. +HINT: Available values: pglz, lz4, zstd_nodict. +SET default_toast_compression = 'zstd_nodict'; SET default_toast_compression = 'lz4'; SET default_toast_compression = 'pglz'; -- test alter compression method diff --git a/src/test/regress/expected/compression_1.out b/src/test/regress/expected/compression_1.out index 7bd7642b4b94..5b10d8c52595 100644 --- a/src/test/regress/expected/compression_1.out +++ b/src/test/regress/expected/compression_1.out @@ -233,6 +233,9 @@ HINT: Available values: pglz. SET default_toast_compression = 'I do not exist compression'; ERROR: invalid value for parameter "default_toast_compression": "I do not exist compression" HINT: Available values: pglz. +SET default_toast_compression = 'zstd_nodict'; +ERROR: invalid value for parameter "default_toast_compression": "zstd_nodict" +HINT: Available values: pglz. SET default_toast_compression = 'lz4'; ERROR: invalid value for parameter "default_toast_compression": "lz4" HINT: Available values: pglz. diff --git a/src/test/regress/sql/compression.sql b/src/test/regress/sql/compression.sql index 490595fcfb26..27979eb79970 100644 --- a/src/test/regress/sql/compression.sql +++ b/src/test/regress/sql/compression.sql @@ -102,6 +102,7 @@ CREATE TABLE cminh() INHERITS (cmdata, cmdata3); -- test default_toast_compression GUC SET default_toast_compression = ''; SET default_toast_compression = 'I do not exist compression'; +SET default_toast_compression = 'zstd_nodict'; SET default_toast_compression = 'lz4'; SET default_toast_compression = 'pglz';