agora inbox for [email protected]help / color / mirror / Atom feed
Incorrect mentions to pg_xlog in walmethods.c/h 51+ messages / 5 participants [nested] [flat]
* Incorrect mentions to pg_xlog in walmethods.c/h @ 2017-06-27 05:26 Michael Paquier <[email protected]> 0 siblings, 1 reply; 51+ messages in thread From: Michael Paquier @ 2017-06-27 05:26 UTC (permalink / raw) To: pgsql-hackers Hi all, I have noticed $subject. A patch is attached. Those comments are not completely wrong either as pg_basebackup can generate pg_xlog as well, still I would recommend to just mention "pg_wal". Thanks, -- Michael -- Sent via pgsql-hackers mailing list ([email protected]) To make changes to your subscription: http://www.postgresql.org/mailpref/pgsql-hackers Attachments: [application/octet-stream] walmethods-comments.patch (1.6K, ../../CAB7nPqT2LSvM_aQxZ2oDT5ifRfjZry-7_s0JmWKv_y4-uvaDmg@mail.gmail.com/2-walmethods-comments.patch) download | inline diff: diff --git a/src/bin/pg_basebackup/walmethods.c b/src/bin/pg_basebackup/walmethods.c index 5fe02dee72..06d8ab5bc2 100644 --- a/src/bin/pg_basebackup/walmethods.c +++ b/src/bin/pg_basebackup/walmethods.c @@ -31,7 +31,7 @@ #define ZLIB_OUT_SIZE 4096 /*------------------------------------------------------------------------- - * WalDirectoryMethod - write wal to a directory looking like pg_xlog + * WalDirectoryMethod - write wal to a directory looking like pg_wal *------------------------------------------------------------------------- */ @@ -375,7 +375,7 @@ FreeWalDirectoryMethod(void) /*------------------------------------------------------------------------- - * WalTarMethod - write wal to a tar file containing pg_xlog contents + * WalTarMethod - write wal to a tar file containing pg_wal contents *------------------------------------------------------------------------- */ diff --git a/src/bin/pg_basebackup/walmethods.h b/src/bin/pg_basebackup/walmethods.h index f9d2f66d84..3fdc947ab9 100644 --- a/src/bin/pg_basebackup/walmethods.h +++ b/src/bin/pg_basebackup/walmethods.h @@ -80,8 +80,8 @@ struct WalWriteMethod /* * Available WAL methods: - * - WalDirectoryMethod - write WAL to regular files in a standard pg_xlog - * - TarDirectoryMethod - write WAL to a tarfile corresponding to pg_xlog + * - WalDirectoryMethod - write WAL to regular files in a standard pg_wal + * - TarDirectoryMethod - write WAL to a tarfile corresponding to pg_wal * (only implements the methods required for pg_basebackup, * not all those required for pg_receivewal) */ ^ permalink raw reply [nested|flat] 51+ messages in thread
* Re: Incorrect mentions to pg_xlog in walmethods.c/h @ 2017-06-30 18:41 Peter Eisentraut <[email protected]> parent: Michael Paquier <[email protected]> 0 siblings, 1 reply; 51+ messages in thread From: Peter Eisentraut @ 2017-06-30 18:41 UTC (permalink / raw) To: Michael Paquier <[email protected]>; pgsql-hackers On 6/27/17 01:26, Michael Paquier wrote: > I have noticed $subject. A patch is attached. Those comments are not > completely wrong either as pg_basebackup can generate pg_xlog as well, > still I would recommend to just mention "pg_wal". committed -- Peter Eisentraut http://www.2ndQuadrant.com/ PostgreSQL Development, 24x7 Support, Remote DBA, Training & Services -- Sent via pgsql-hackers mailing list ([email protected]) To make changes to your subscription: http://www.postgresql.org/mailpref/pgsql-hackers ^ permalink raw reply [nested|flat] 51+ messages in thread
* Re: Incorrect mentions to pg_xlog in walmethods.c/h @ 2017-06-30 23:56 Michael Paquier <[email protected]> parent: Peter Eisentraut <[email protected]> 0 siblings, 0 replies; 51+ messages in thread From: Michael Paquier @ 2017-06-30 23:56 UTC (permalink / raw) To: Peter Eisentraut <[email protected]>; +Cc: pgsql-hackers On Sat, Jul 1, 2017 at 3:41 AM, Peter Eisentraut <[email protected]> wrote: > On 6/27/17 01:26, Michael Paquier wrote: >> I have noticed $subject. A patch is attached. Those comments are not >> completely wrong either as pg_basebackup can generate pg_xlog as well, >> still I would recommend to just mention "pg_wal". > > committed Thanks. -- Michael -- Sent via pgsql-hackers mailing list ([email protected]) To make changes to your subscription: http://www.postgresql.org/mailpref/pgsql-hackers ^ permalink raw reply [nested|flat] 51+ messages in thread
* [PATCH v24 5/7] fixups.patch @ 2021-02-10 21:56 Robert Haas <[email protected]> 0 siblings, 0 replies; 51+ messages in thread From: Robert Haas @ 2021-02-10 21:56 UTC (permalink / raw) --- doc/src/sgml/ddl.sgml | 3 --- doc/src/sgml/ref/create_table.sgml | 15 +++++++++++---- src/backend/access/common/detoast.c | 5 ++--- src/backend/access/compression/compress_lz4.c | 10 +++++----- src/backend/executor/nodeModifyTable.c | 2 +- src/include/nodes/execnodes.h | 4 ++-- 6 files changed, 21 insertions(+), 18 deletions(-) diff --git a/doc/src/sgml/ddl.sgml b/doc/src/sgml/ddl.sgml index 4d7ed698b9..1e9a4625cc 100644 --- a/doc/src/sgml/ddl.sgml +++ b/doc/src/sgml/ddl.sgml @@ -3762,9 +3762,6 @@ CREATE TABLE measurement ( <productname>PostgreSQL</productname> tables (or, possibly, foreign tables). It is possible to specify a tablespace and storage parameters for each partition separately. - By default, each column in a partition inherits the compression method - from parent table's column, however a different compression method can be - set for each partition. </para> <para> diff --git a/doc/src/sgml/ref/create_table.sgml b/doc/src/sgml/ref/create_table.sgml index 51a7a977a5..a4b297340f 100644 --- a/doc/src/sgml/ref/create_table.sgml +++ b/doc/src/sgml/ref/create_table.sgml @@ -997,10 +997,17 @@ WITH ( MODULUS <replaceable class="parameter">numeric_literal</replaceable>, REM <term><literal>COMPRESSION <replaceable class="parameter">compression_method</replaceable></literal></term> <listitem> <para> - This sets the compression method for a column. The supported compression - methods are <literal>pglz</literal> and <literal>lz4</literal>. - <literal>lz4</literal> is available only if <literal>--with-lz4</literal> - was used when building <productname>PostgreSQL</productname>. The default + The <literal>COMPRESSION</literal> clause sets the compression method + for a column. Compression is supported only for variable-width data + types, and is used only for columns whose storage type is main or + extended. (See <xref linkend="sql-altertable"/> for information on + column storage types.) Setting this property for a partitioned table + has no direct effect, because such tables have no storage of their own, + but the configured value is inherited by newly-created partitions. + The supported compression methods are <literal>pglz</literal> and + <literal>lz4</literal>. <literal>lz4</literal> is available only if + <literal>--with-lz4</literal> was used when building + <productname>PostgreSQL</productname>. The default is <literal>pglz</literal>. </para> </listitem> diff --git a/src/backend/access/common/detoast.c b/src/backend/access/common/detoast.c index b78d49167b..95d5b1c12a 100644 --- a/src/backend/access/common/detoast.c +++ b/src/backend/access/common/detoast.c @@ -477,8 +477,8 @@ toast_get_compression_oid(struct varlena *attr) return InvalidOid; /* - * Just fetch the toast compress header to know the compression method - * in the compressed data. + * Fetch just enough of the value to examine the compression header, + * so that we can find out the compression method. */ attr = toast_fetch_datum_slice(attr, 0, VARHDRSZ_COMPRESS); } @@ -503,7 +503,6 @@ toast_get_compression_handler(struct varlena *attr) cmid = TOAST_COMPRESS_METHOD(attr); - /* Get the handler routines for the compression method */ switch (cmid) { case PGLZ_COMPRESSION_ID: diff --git a/src/backend/access/compression/compress_lz4.c b/src/backend/access/compression/compress_lz4.c index 1856cf7df7..3079eff7eb 100644 --- a/src/backend/access/compression/compress_lz4.c +++ b/src/backend/access/compression/compress_lz4.c @@ -23,7 +23,7 @@ /* * lz4_cmcompress - compression routine for lz4 compression method * - * Compresses source into dest using the default strategy. Returns the + * Compresses source into dest using the LZ4 defaults. Returns the * compressed varlena, or NULL if compression fails. */ static struct varlena * @@ -42,8 +42,8 @@ lz4_cmcompress(const struct varlena *value) valsize = VARSIZE_ANY_EXHDR(value); /* - * Get maximum size of the compressed data that lz4 compression may output - * and allocate the memory for holding the compressed data and the header. + * 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_COMPRESS); @@ -83,10 +83,10 @@ lz4_cmdecompress(const struct varlena *value) int32 rawsize; struct varlena *result; - /* allocate memory for holding the uncompressed data */ + /* allocate memory for the uncompressed data */ result = (struct varlena *) palloc(VARRAWSIZE_4B_C(value) + VARHDRSZ); - /* decompress data using lz4 routine */ + /* decompress the data */ rawsize = LZ4_decompress_safe((char *) value + VARHDRSZ_COMPRESS, VARDATA(result), VARSIZE(value) - VARHDRSZ_COMPRESS, diff --git a/src/backend/executor/nodeModifyTable.c b/src/backend/executor/nodeModifyTable.c index f77deee399..920d9dd0d5 100644 --- a/src/backend/executor/nodeModifyTable.c +++ b/src/backend/executor/nodeModifyTable.c @@ -2117,7 +2117,7 @@ CompareCompressionMethodAndDecompress(TupleTableSlot *slot, TupleTableSlot *newslot = *outslot; /* - * If the called has passed an invalid slot then create a new slot. + * If the caller has passed an invalid slot then create a new slot. * Otherwise, just clear the existing tuple from the slot. This slot * should be stored by the caller so that it can be reused for * decompressing the subsequent tuples. diff --git a/src/include/nodes/execnodes.h b/src/include/nodes/execnodes.h index 18e8ecfd90..d8483c36b3 100644 --- a/src/include/nodes/execnodes.h +++ b/src/include/nodes/execnodes.h @@ -1183,8 +1183,8 @@ typedef struct ModifyTableState TupleTableSlot *mt_root_tuple_slot; /* - * Slot for storing the modified tuple, incase the target attribute's - * compression method doesn't match with the source table. + * Slot for storing the modified tuple, in case the target attribute's + * compression method doesn't match that of the source table. */ TupleTableSlot *mt_decompress_tuple_slot; -- 2.17.0 --YZ5djTAD1cGYuMQK Content-Type: text/x-diff; charset=us-ascii Content-Disposition: attachment; filename="v24-0006-alter-table-set-compression.patch" ^ permalink raw reply [nested|flat] 51+ messages in thread
* [PATCH v24 05/10] fixups.patch @ 2021-02-10 21:56 Robert Haas <[email protected]> 0 siblings, 0 replies; 51+ messages in thread From: Robert Haas @ 2021-02-10 21:56 UTC (permalink / raw) --- doc/src/sgml/ddl.sgml | 3 --- doc/src/sgml/ref/create_table.sgml | 15 +++++++++++---- src/backend/access/common/detoast.c | 5 ++--- src/backend/access/compression/compress_lz4.c | 10 +++++----- src/backend/executor/nodeModifyTable.c | 2 +- src/include/nodes/execnodes.h | 4 ++-- 6 files changed, 21 insertions(+), 18 deletions(-) diff --git a/doc/src/sgml/ddl.sgml b/doc/src/sgml/ddl.sgml index 4d7ed698b9..1e9a4625cc 100644 --- a/doc/src/sgml/ddl.sgml +++ b/doc/src/sgml/ddl.sgml @@ -3762,9 +3762,6 @@ CREATE TABLE measurement ( <productname>PostgreSQL</productname> tables (or, possibly, foreign tables). It is possible to specify a tablespace and storage parameters for each partition separately. - By default, each column in a partition inherits the compression method - from parent table's column, however a different compression method can be - set for each partition. </para> <para> diff --git a/doc/src/sgml/ref/create_table.sgml b/doc/src/sgml/ref/create_table.sgml index 51a7a977a5..a4b297340f 100644 --- a/doc/src/sgml/ref/create_table.sgml +++ b/doc/src/sgml/ref/create_table.sgml @@ -997,10 +997,17 @@ WITH ( MODULUS <replaceable class="parameter">numeric_literal</replaceable>, REM <term><literal>COMPRESSION <replaceable class="parameter">compression_method</replaceable></literal></term> <listitem> <para> - This sets the compression method for a column. The supported compression - methods are <literal>pglz</literal> and <literal>lz4</literal>. - <literal>lz4</literal> is available only if <literal>--with-lz4</literal> - was used when building <productname>PostgreSQL</productname>. The default + The <literal>COMPRESSION</literal> clause sets the compression method + for a column. Compression is supported only for variable-width data + types, and is used only for columns whose storage type is main or + extended. (See <xref linkend="sql-altertable"/> for information on + column storage types.) Setting this property for a partitioned table + has no direct effect, because such tables have no storage of their own, + but the configured value is inherited by newly-created partitions. + The supported compression methods are <literal>pglz</literal> and + <literal>lz4</literal>. <literal>lz4</literal> is available only if + <literal>--with-lz4</literal> was used when building + <productname>PostgreSQL</productname>. The default is <literal>pglz</literal>. </para> </listitem> diff --git a/src/backend/access/common/detoast.c b/src/backend/access/common/detoast.c index b78d49167b..95d5b1c12a 100644 --- a/src/backend/access/common/detoast.c +++ b/src/backend/access/common/detoast.c @@ -477,8 +477,8 @@ toast_get_compression_oid(struct varlena *attr) return InvalidOid; /* - * Just fetch the toast compress header to know the compression method - * in the compressed data. + * Fetch just enough of the value to examine the compression header, + * so that we can find out the compression method. */ attr = toast_fetch_datum_slice(attr, 0, VARHDRSZ_COMPRESS); } @@ -503,7 +503,6 @@ toast_get_compression_handler(struct varlena *attr) cmid = TOAST_COMPRESS_METHOD(attr); - /* Get the handler routines for the compression method */ switch (cmid) { case PGLZ_COMPRESSION_ID: diff --git a/src/backend/access/compression/compress_lz4.c b/src/backend/access/compression/compress_lz4.c index 1856cf7df7..3079eff7eb 100644 --- a/src/backend/access/compression/compress_lz4.c +++ b/src/backend/access/compression/compress_lz4.c @@ -23,7 +23,7 @@ /* * lz4_cmcompress - compression routine for lz4 compression method * - * Compresses source into dest using the default strategy. Returns the + * Compresses source into dest using the LZ4 defaults. Returns the * compressed varlena, or NULL if compression fails. */ static struct varlena * @@ -42,8 +42,8 @@ lz4_cmcompress(const struct varlena *value) valsize = VARSIZE_ANY_EXHDR(value); /* - * Get maximum size of the compressed data that lz4 compression may output - * and allocate the memory for holding the compressed data and the header. + * 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_COMPRESS); @@ -83,10 +83,10 @@ lz4_cmdecompress(const struct varlena *value) int32 rawsize; struct varlena *result; - /* allocate memory for holding the uncompressed data */ + /* allocate memory for the uncompressed data */ result = (struct varlena *) palloc(VARRAWSIZE_4B_C(value) + VARHDRSZ); - /* decompress data using lz4 routine */ + /* decompress the data */ rawsize = LZ4_decompress_safe((char *) value + VARHDRSZ_COMPRESS, VARDATA(result), VARSIZE(value) - VARHDRSZ_COMPRESS, diff --git a/src/backend/executor/nodeModifyTable.c b/src/backend/executor/nodeModifyTable.c index f77deee399..920d9dd0d5 100644 --- a/src/backend/executor/nodeModifyTable.c +++ b/src/backend/executor/nodeModifyTable.c @@ -2117,7 +2117,7 @@ CompareCompressionMethodAndDecompress(TupleTableSlot *slot, TupleTableSlot *newslot = *outslot; /* - * If the called has passed an invalid slot then create a new slot. + * If the caller has passed an invalid slot then create a new slot. * Otherwise, just clear the existing tuple from the slot. This slot * should be stored by the caller so that it can be reused for * decompressing the subsequent tuples. diff --git a/src/include/nodes/execnodes.h b/src/include/nodes/execnodes.h index 18e8ecfd90..d8483c36b3 100644 --- a/src/include/nodes/execnodes.h +++ b/src/include/nodes/execnodes.h @@ -1183,8 +1183,8 @@ typedef struct ModifyTableState TupleTableSlot *mt_root_tuple_slot; /* - * Slot for storing the modified tuple, incase the target attribute's - * compression method doesn't match with the source table. + * Slot for storing the modified tuple, in case the target attribute's + * compression method doesn't match that of the source table. */ TupleTableSlot *mt_decompress_tuple_slot; -- 2.17.0 --m51xatjYGsM+13rf Content-Type: text/x-diff; charset=us-ascii Content-Disposition: attachment; filename="v24-0006-alter-table-set-compression.patch" ^ permalink raw reply [nested|flat] 51+ messages in thread
* [PATCH v24 5/7] fixups.patch @ 2021-02-10 21:56 Robert Haas <[email protected]> 0 siblings, 0 replies; 51+ messages in thread From: Robert Haas @ 2021-02-10 21:56 UTC (permalink / raw) --- doc/src/sgml/ddl.sgml | 3 --- doc/src/sgml/ref/create_table.sgml | 15 +++++++++++---- src/backend/access/common/detoast.c | 5 ++--- src/backend/access/compression/compress_lz4.c | 10 +++++----- src/backend/executor/nodeModifyTable.c | 2 +- src/include/nodes/execnodes.h | 4 ++-- 6 files changed, 21 insertions(+), 18 deletions(-) diff --git a/doc/src/sgml/ddl.sgml b/doc/src/sgml/ddl.sgml index 4d7ed698b9..1e9a4625cc 100644 --- a/doc/src/sgml/ddl.sgml +++ b/doc/src/sgml/ddl.sgml @@ -3762,9 +3762,6 @@ CREATE TABLE measurement ( <productname>PostgreSQL</productname> tables (or, possibly, foreign tables). It is possible to specify a tablespace and storage parameters for each partition separately. - By default, each column in a partition inherits the compression method - from parent table's column, however a different compression method can be - set for each partition. </para> <para> diff --git a/doc/src/sgml/ref/create_table.sgml b/doc/src/sgml/ref/create_table.sgml index 51a7a977a5..a4b297340f 100644 --- a/doc/src/sgml/ref/create_table.sgml +++ b/doc/src/sgml/ref/create_table.sgml @@ -997,10 +997,17 @@ WITH ( MODULUS <replaceable class="parameter">numeric_literal</replaceable>, REM <term><literal>COMPRESSION <replaceable class="parameter">compression_method</replaceable></literal></term> <listitem> <para> - This sets the compression method for a column. The supported compression - methods are <literal>pglz</literal> and <literal>lz4</literal>. - <literal>lz4</literal> is available only if <literal>--with-lz4</literal> - was used when building <productname>PostgreSQL</productname>. The default + The <literal>COMPRESSION</literal> clause sets the compression method + for a column. Compression is supported only for variable-width data + types, and is used only for columns whose storage type is main or + extended. (See <xref linkend="sql-altertable"/> for information on + column storage types.) Setting this property for a partitioned table + has no direct effect, because such tables have no storage of their own, + but the configured value is inherited by newly-created partitions. + The supported compression methods are <literal>pglz</literal> and + <literal>lz4</literal>. <literal>lz4</literal> is available only if + <literal>--with-lz4</literal> was used when building + <productname>PostgreSQL</productname>. The default is <literal>pglz</literal>. </para> </listitem> diff --git a/src/backend/access/common/detoast.c b/src/backend/access/common/detoast.c index b78d49167b..95d5b1c12a 100644 --- a/src/backend/access/common/detoast.c +++ b/src/backend/access/common/detoast.c @@ -477,8 +477,8 @@ toast_get_compression_oid(struct varlena *attr) return InvalidOid; /* - * Just fetch the toast compress header to know the compression method - * in the compressed data. + * Fetch just enough of the value to examine the compression header, + * so that we can find out the compression method. */ attr = toast_fetch_datum_slice(attr, 0, VARHDRSZ_COMPRESS); } @@ -503,7 +503,6 @@ toast_get_compression_handler(struct varlena *attr) cmid = TOAST_COMPRESS_METHOD(attr); - /* Get the handler routines for the compression method */ switch (cmid) { case PGLZ_COMPRESSION_ID: diff --git a/src/backend/access/compression/compress_lz4.c b/src/backend/access/compression/compress_lz4.c index 1856cf7df7..3079eff7eb 100644 --- a/src/backend/access/compression/compress_lz4.c +++ b/src/backend/access/compression/compress_lz4.c @@ -23,7 +23,7 @@ /* * lz4_cmcompress - compression routine for lz4 compression method * - * Compresses source into dest using the default strategy. Returns the + * Compresses source into dest using the LZ4 defaults. Returns the * compressed varlena, or NULL if compression fails. */ static struct varlena * @@ -42,8 +42,8 @@ lz4_cmcompress(const struct varlena *value) valsize = VARSIZE_ANY_EXHDR(value); /* - * Get maximum size of the compressed data that lz4 compression may output - * and allocate the memory for holding the compressed data and the header. + * 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_COMPRESS); @@ -83,10 +83,10 @@ lz4_cmdecompress(const struct varlena *value) int32 rawsize; struct varlena *result; - /* allocate memory for holding the uncompressed data */ + /* allocate memory for the uncompressed data */ result = (struct varlena *) palloc(VARRAWSIZE_4B_C(value) + VARHDRSZ); - /* decompress data using lz4 routine */ + /* decompress the data */ rawsize = LZ4_decompress_safe((char *) value + VARHDRSZ_COMPRESS, VARDATA(result), VARSIZE(value) - VARHDRSZ_COMPRESS, diff --git a/src/backend/executor/nodeModifyTable.c b/src/backend/executor/nodeModifyTable.c index f77deee399..920d9dd0d5 100644 --- a/src/backend/executor/nodeModifyTable.c +++ b/src/backend/executor/nodeModifyTable.c @@ -2117,7 +2117,7 @@ CompareCompressionMethodAndDecompress(TupleTableSlot *slot, TupleTableSlot *newslot = *outslot; /* - * If the called has passed an invalid slot then create a new slot. + * If the caller has passed an invalid slot then create a new slot. * Otherwise, just clear the existing tuple from the slot. This slot * should be stored by the caller so that it can be reused for * decompressing the subsequent tuples. diff --git a/src/include/nodes/execnodes.h b/src/include/nodes/execnodes.h index 18e8ecfd90..d8483c36b3 100644 --- a/src/include/nodes/execnodes.h +++ b/src/include/nodes/execnodes.h @@ -1183,8 +1183,8 @@ typedef struct ModifyTableState TupleTableSlot *mt_root_tuple_slot; /* - * Slot for storing the modified tuple, incase the target attribute's - * compression method doesn't match with the source table. + * Slot for storing the modified tuple, in case the target attribute's + * compression method doesn't match that of the source table. */ TupleTableSlot *mt_decompress_tuple_slot; -- 2.17.0 --YZ5djTAD1cGYuMQK Content-Type: text/x-diff; charset=us-ascii Content-Disposition: attachment; filename="v24-0006-alter-table-set-compression.patch" ^ permalink raw reply [nested|flat] 51+ messages in thread
* [PATCH v24 05/10] fixups.patch @ 2021-02-10 21:56 Robert Haas <[email protected]> 0 siblings, 0 replies; 51+ messages in thread From: Robert Haas @ 2021-02-10 21:56 UTC (permalink / raw) --- doc/src/sgml/ddl.sgml | 3 --- doc/src/sgml/ref/create_table.sgml | 15 +++++++++++---- src/backend/access/common/detoast.c | 5 ++--- src/backend/access/compression/compress_lz4.c | 10 +++++----- src/backend/executor/nodeModifyTable.c | 2 +- src/include/nodes/execnodes.h | 4 ++-- 6 files changed, 21 insertions(+), 18 deletions(-) diff --git a/doc/src/sgml/ddl.sgml b/doc/src/sgml/ddl.sgml index 4d7ed698b9..1e9a4625cc 100644 --- a/doc/src/sgml/ddl.sgml +++ b/doc/src/sgml/ddl.sgml @@ -3762,9 +3762,6 @@ CREATE TABLE measurement ( <productname>PostgreSQL</productname> tables (or, possibly, foreign tables). It is possible to specify a tablespace and storage parameters for each partition separately. - By default, each column in a partition inherits the compression method - from parent table's column, however a different compression method can be - set for each partition. </para> <para> diff --git a/doc/src/sgml/ref/create_table.sgml b/doc/src/sgml/ref/create_table.sgml index 51a7a977a5..a4b297340f 100644 --- a/doc/src/sgml/ref/create_table.sgml +++ b/doc/src/sgml/ref/create_table.sgml @@ -997,10 +997,17 @@ WITH ( MODULUS <replaceable class="parameter">numeric_literal</replaceable>, REM <term><literal>COMPRESSION <replaceable class="parameter">compression_method</replaceable></literal></term> <listitem> <para> - This sets the compression method for a column. The supported compression - methods are <literal>pglz</literal> and <literal>lz4</literal>. - <literal>lz4</literal> is available only if <literal>--with-lz4</literal> - was used when building <productname>PostgreSQL</productname>. The default + The <literal>COMPRESSION</literal> clause sets the compression method + for a column. Compression is supported only for variable-width data + types, and is used only for columns whose storage type is main or + extended. (See <xref linkend="sql-altertable"/> for information on + column storage types.) Setting this property for a partitioned table + has no direct effect, because such tables have no storage of their own, + but the configured value is inherited by newly-created partitions. + The supported compression methods are <literal>pglz</literal> and + <literal>lz4</literal>. <literal>lz4</literal> is available only if + <literal>--with-lz4</literal> was used when building + <productname>PostgreSQL</productname>. The default is <literal>pglz</literal>. </para> </listitem> diff --git a/src/backend/access/common/detoast.c b/src/backend/access/common/detoast.c index b78d49167b..95d5b1c12a 100644 --- a/src/backend/access/common/detoast.c +++ b/src/backend/access/common/detoast.c @@ -477,8 +477,8 @@ toast_get_compression_oid(struct varlena *attr) return InvalidOid; /* - * Just fetch the toast compress header to know the compression method - * in the compressed data. + * Fetch just enough of the value to examine the compression header, + * so that we can find out the compression method. */ attr = toast_fetch_datum_slice(attr, 0, VARHDRSZ_COMPRESS); } @@ -503,7 +503,6 @@ toast_get_compression_handler(struct varlena *attr) cmid = TOAST_COMPRESS_METHOD(attr); - /* Get the handler routines for the compression method */ switch (cmid) { case PGLZ_COMPRESSION_ID: diff --git a/src/backend/access/compression/compress_lz4.c b/src/backend/access/compression/compress_lz4.c index 1856cf7df7..3079eff7eb 100644 --- a/src/backend/access/compression/compress_lz4.c +++ b/src/backend/access/compression/compress_lz4.c @@ -23,7 +23,7 @@ /* * lz4_cmcompress - compression routine for lz4 compression method * - * Compresses source into dest using the default strategy. Returns the + * Compresses source into dest using the LZ4 defaults. Returns the * compressed varlena, or NULL if compression fails. */ static struct varlena * @@ -42,8 +42,8 @@ lz4_cmcompress(const struct varlena *value) valsize = VARSIZE_ANY_EXHDR(value); /* - * Get maximum size of the compressed data that lz4 compression may output - * and allocate the memory for holding the compressed data and the header. + * 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_COMPRESS); @@ -83,10 +83,10 @@ lz4_cmdecompress(const struct varlena *value) int32 rawsize; struct varlena *result; - /* allocate memory for holding the uncompressed data */ + /* allocate memory for the uncompressed data */ result = (struct varlena *) palloc(VARRAWSIZE_4B_C(value) + VARHDRSZ); - /* decompress data using lz4 routine */ + /* decompress the data */ rawsize = LZ4_decompress_safe((char *) value + VARHDRSZ_COMPRESS, VARDATA(result), VARSIZE(value) - VARHDRSZ_COMPRESS, diff --git a/src/backend/executor/nodeModifyTable.c b/src/backend/executor/nodeModifyTable.c index f77deee399..920d9dd0d5 100644 --- a/src/backend/executor/nodeModifyTable.c +++ b/src/backend/executor/nodeModifyTable.c @@ -2117,7 +2117,7 @@ CompareCompressionMethodAndDecompress(TupleTableSlot *slot, TupleTableSlot *newslot = *outslot; /* - * If the called has passed an invalid slot then create a new slot. + * If the caller has passed an invalid slot then create a new slot. * Otherwise, just clear the existing tuple from the slot. This slot * should be stored by the caller so that it can be reused for * decompressing the subsequent tuples. diff --git a/src/include/nodes/execnodes.h b/src/include/nodes/execnodes.h index 18e8ecfd90..d8483c36b3 100644 --- a/src/include/nodes/execnodes.h +++ b/src/include/nodes/execnodes.h @@ -1183,8 +1183,8 @@ typedef struct ModifyTableState TupleTableSlot *mt_root_tuple_slot; /* - * Slot for storing the modified tuple, incase the target attribute's - * compression method doesn't match with the source table. + * Slot for storing the modified tuple, in case the target attribute's + * compression method doesn't match that of the source table. */ TupleTableSlot *mt_decompress_tuple_slot; -- 2.17.0 --m51xatjYGsM+13rf Content-Type: text/x-diff; charset=us-ascii Content-Disposition: attachment; filename="v24-0006-alter-table-set-compression.patch" ^ permalink raw reply [nested|flat] 51+ messages in thread
* [PATCH v24 5/7] fixups.patch @ 2021-02-10 21:56 Robert Haas <[email protected]> 0 siblings, 0 replies; 51+ messages in thread From: Robert Haas @ 2021-02-10 21:56 UTC (permalink / raw) --- doc/src/sgml/ddl.sgml | 3 --- doc/src/sgml/ref/create_table.sgml | 15 +++++++++++---- src/backend/access/common/detoast.c | 5 ++--- src/backend/access/compression/compress_lz4.c | 10 +++++----- src/backend/executor/nodeModifyTable.c | 2 +- src/include/nodes/execnodes.h | 4 ++-- 6 files changed, 21 insertions(+), 18 deletions(-) diff --git a/doc/src/sgml/ddl.sgml b/doc/src/sgml/ddl.sgml index 4d7ed698b9..1e9a4625cc 100644 --- a/doc/src/sgml/ddl.sgml +++ b/doc/src/sgml/ddl.sgml @@ -3762,9 +3762,6 @@ CREATE TABLE measurement ( <productname>PostgreSQL</productname> tables (or, possibly, foreign tables). It is possible to specify a tablespace and storage parameters for each partition separately. - By default, each column in a partition inherits the compression method - from parent table's column, however a different compression method can be - set for each partition. </para> <para> diff --git a/doc/src/sgml/ref/create_table.sgml b/doc/src/sgml/ref/create_table.sgml index 51a7a977a5..a4b297340f 100644 --- a/doc/src/sgml/ref/create_table.sgml +++ b/doc/src/sgml/ref/create_table.sgml @@ -997,10 +997,17 @@ WITH ( MODULUS <replaceable class="parameter">numeric_literal</replaceable>, REM <term><literal>COMPRESSION <replaceable class="parameter">compression_method</replaceable></literal></term> <listitem> <para> - This sets the compression method for a column. The supported compression - methods are <literal>pglz</literal> and <literal>lz4</literal>. - <literal>lz4</literal> is available only if <literal>--with-lz4</literal> - was used when building <productname>PostgreSQL</productname>. The default + The <literal>COMPRESSION</literal> clause sets the compression method + for a column. Compression is supported only for variable-width data + types, and is used only for columns whose storage type is main or + extended. (See <xref linkend="sql-altertable"/> for information on + column storage types.) Setting this property for a partitioned table + has no direct effect, because such tables have no storage of their own, + but the configured value is inherited by newly-created partitions. + The supported compression methods are <literal>pglz</literal> and + <literal>lz4</literal>. <literal>lz4</literal> is available only if + <literal>--with-lz4</literal> was used when building + <productname>PostgreSQL</productname>. The default is <literal>pglz</literal>. </para> </listitem> diff --git a/src/backend/access/common/detoast.c b/src/backend/access/common/detoast.c index b78d49167b..95d5b1c12a 100644 --- a/src/backend/access/common/detoast.c +++ b/src/backend/access/common/detoast.c @@ -477,8 +477,8 @@ toast_get_compression_oid(struct varlena *attr) return InvalidOid; /* - * Just fetch the toast compress header to know the compression method - * in the compressed data. + * Fetch just enough of the value to examine the compression header, + * so that we can find out the compression method. */ attr = toast_fetch_datum_slice(attr, 0, VARHDRSZ_COMPRESS); } @@ -503,7 +503,6 @@ toast_get_compression_handler(struct varlena *attr) cmid = TOAST_COMPRESS_METHOD(attr); - /* Get the handler routines for the compression method */ switch (cmid) { case PGLZ_COMPRESSION_ID: diff --git a/src/backend/access/compression/compress_lz4.c b/src/backend/access/compression/compress_lz4.c index 1856cf7df7..3079eff7eb 100644 --- a/src/backend/access/compression/compress_lz4.c +++ b/src/backend/access/compression/compress_lz4.c @@ -23,7 +23,7 @@ /* * lz4_cmcompress - compression routine for lz4 compression method * - * Compresses source into dest using the default strategy. Returns the + * Compresses source into dest using the LZ4 defaults. Returns the * compressed varlena, or NULL if compression fails. */ static struct varlena * @@ -42,8 +42,8 @@ lz4_cmcompress(const struct varlena *value) valsize = VARSIZE_ANY_EXHDR(value); /* - * Get maximum size of the compressed data that lz4 compression may output - * and allocate the memory for holding the compressed data and the header. + * 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_COMPRESS); @@ -83,10 +83,10 @@ lz4_cmdecompress(const struct varlena *value) int32 rawsize; struct varlena *result; - /* allocate memory for holding the uncompressed data */ + /* allocate memory for the uncompressed data */ result = (struct varlena *) palloc(VARRAWSIZE_4B_C(value) + VARHDRSZ); - /* decompress data using lz4 routine */ + /* decompress the data */ rawsize = LZ4_decompress_safe((char *) value + VARHDRSZ_COMPRESS, VARDATA(result), VARSIZE(value) - VARHDRSZ_COMPRESS, diff --git a/src/backend/executor/nodeModifyTable.c b/src/backend/executor/nodeModifyTable.c index f77deee399..920d9dd0d5 100644 --- a/src/backend/executor/nodeModifyTable.c +++ b/src/backend/executor/nodeModifyTable.c @@ -2117,7 +2117,7 @@ CompareCompressionMethodAndDecompress(TupleTableSlot *slot, TupleTableSlot *newslot = *outslot; /* - * If the called has passed an invalid slot then create a new slot. + * If the caller has passed an invalid slot then create a new slot. * Otherwise, just clear the existing tuple from the slot. This slot * should be stored by the caller so that it can be reused for * decompressing the subsequent tuples. diff --git a/src/include/nodes/execnodes.h b/src/include/nodes/execnodes.h index 18e8ecfd90..d8483c36b3 100644 --- a/src/include/nodes/execnodes.h +++ b/src/include/nodes/execnodes.h @@ -1183,8 +1183,8 @@ typedef struct ModifyTableState TupleTableSlot *mt_root_tuple_slot; /* - * Slot for storing the modified tuple, incase the target attribute's - * compression method doesn't match with the source table. + * Slot for storing the modified tuple, in case the target attribute's + * compression method doesn't match that of the source table. */ TupleTableSlot *mt_decompress_tuple_slot; -- 2.17.0 --YZ5djTAD1cGYuMQK Content-Type: text/x-diff; charset=us-ascii Content-Disposition: attachment; filename="v24-0006-alter-table-set-compression.patch" ^ permalink raw reply [nested|flat] 51+ messages in thread
* [PATCH v24 05/10] fixups.patch @ 2021-02-10 21:56 Robert Haas <[email protected]> 0 siblings, 0 replies; 51+ messages in thread From: Robert Haas @ 2021-02-10 21:56 UTC (permalink / raw) --- doc/src/sgml/ddl.sgml | 3 --- doc/src/sgml/ref/create_table.sgml | 15 +++++++++++---- src/backend/access/common/detoast.c | 5 ++--- src/backend/access/compression/compress_lz4.c | 10 +++++----- src/backend/executor/nodeModifyTable.c | 2 +- src/include/nodes/execnodes.h | 4 ++-- 6 files changed, 21 insertions(+), 18 deletions(-) diff --git a/doc/src/sgml/ddl.sgml b/doc/src/sgml/ddl.sgml index 4d7ed698b9..1e9a4625cc 100644 --- a/doc/src/sgml/ddl.sgml +++ b/doc/src/sgml/ddl.sgml @@ -3762,9 +3762,6 @@ CREATE TABLE measurement ( <productname>PostgreSQL</productname> tables (or, possibly, foreign tables). It is possible to specify a tablespace and storage parameters for each partition separately. - By default, each column in a partition inherits the compression method - from parent table's column, however a different compression method can be - set for each partition. </para> <para> diff --git a/doc/src/sgml/ref/create_table.sgml b/doc/src/sgml/ref/create_table.sgml index 51a7a977a5..a4b297340f 100644 --- a/doc/src/sgml/ref/create_table.sgml +++ b/doc/src/sgml/ref/create_table.sgml @@ -997,10 +997,17 @@ WITH ( MODULUS <replaceable class="parameter">numeric_literal</replaceable>, REM <term><literal>COMPRESSION <replaceable class="parameter">compression_method</replaceable></literal></term> <listitem> <para> - This sets the compression method for a column. The supported compression - methods are <literal>pglz</literal> and <literal>lz4</literal>. - <literal>lz4</literal> is available only if <literal>--with-lz4</literal> - was used when building <productname>PostgreSQL</productname>. The default + The <literal>COMPRESSION</literal> clause sets the compression method + for a column. Compression is supported only for variable-width data + types, and is used only for columns whose storage type is main or + extended. (See <xref linkend="sql-altertable"/> for information on + column storage types.) Setting this property for a partitioned table + has no direct effect, because such tables have no storage of their own, + but the configured value is inherited by newly-created partitions. + The supported compression methods are <literal>pglz</literal> and + <literal>lz4</literal>. <literal>lz4</literal> is available only if + <literal>--with-lz4</literal> was used when building + <productname>PostgreSQL</productname>. The default is <literal>pglz</literal>. </para> </listitem> diff --git a/src/backend/access/common/detoast.c b/src/backend/access/common/detoast.c index b78d49167b..95d5b1c12a 100644 --- a/src/backend/access/common/detoast.c +++ b/src/backend/access/common/detoast.c @@ -477,8 +477,8 @@ toast_get_compression_oid(struct varlena *attr) return InvalidOid; /* - * Just fetch the toast compress header to know the compression method - * in the compressed data. + * Fetch just enough of the value to examine the compression header, + * so that we can find out the compression method. */ attr = toast_fetch_datum_slice(attr, 0, VARHDRSZ_COMPRESS); } @@ -503,7 +503,6 @@ toast_get_compression_handler(struct varlena *attr) cmid = TOAST_COMPRESS_METHOD(attr); - /* Get the handler routines for the compression method */ switch (cmid) { case PGLZ_COMPRESSION_ID: diff --git a/src/backend/access/compression/compress_lz4.c b/src/backend/access/compression/compress_lz4.c index 1856cf7df7..3079eff7eb 100644 --- a/src/backend/access/compression/compress_lz4.c +++ b/src/backend/access/compression/compress_lz4.c @@ -23,7 +23,7 @@ /* * lz4_cmcompress - compression routine for lz4 compression method * - * Compresses source into dest using the default strategy. Returns the + * Compresses source into dest using the LZ4 defaults. Returns the * compressed varlena, or NULL if compression fails. */ static struct varlena * @@ -42,8 +42,8 @@ lz4_cmcompress(const struct varlena *value) valsize = VARSIZE_ANY_EXHDR(value); /* - * Get maximum size of the compressed data that lz4 compression may output - * and allocate the memory for holding the compressed data and the header. + * 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_COMPRESS); @@ -83,10 +83,10 @@ lz4_cmdecompress(const struct varlena *value) int32 rawsize; struct varlena *result; - /* allocate memory for holding the uncompressed data */ + /* allocate memory for the uncompressed data */ result = (struct varlena *) palloc(VARRAWSIZE_4B_C(value) + VARHDRSZ); - /* decompress data using lz4 routine */ + /* decompress the data */ rawsize = LZ4_decompress_safe((char *) value + VARHDRSZ_COMPRESS, VARDATA(result), VARSIZE(value) - VARHDRSZ_COMPRESS, diff --git a/src/backend/executor/nodeModifyTable.c b/src/backend/executor/nodeModifyTable.c index f77deee399..920d9dd0d5 100644 --- a/src/backend/executor/nodeModifyTable.c +++ b/src/backend/executor/nodeModifyTable.c @@ -2117,7 +2117,7 @@ CompareCompressionMethodAndDecompress(TupleTableSlot *slot, TupleTableSlot *newslot = *outslot; /* - * If the called has passed an invalid slot then create a new slot. + * If the caller has passed an invalid slot then create a new slot. * Otherwise, just clear the existing tuple from the slot. This slot * should be stored by the caller so that it can be reused for * decompressing the subsequent tuples. diff --git a/src/include/nodes/execnodes.h b/src/include/nodes/execnodes.h index 18e8ecfd90..d8483c36b3 100644 --- a/src/include/nodes/execnodes.h +++ b/src/include/nodes/execnodes.h @@ -1183,8 +1183,8 @@ typedef struct ModifyTableState TupleTableSlot *mt_root_tuple_slot; /* - * Slot for storing the modified tuple, incase the target attribute's - * compression method doesn't match with the source table. + * Slot for storing the modified tuple, in case the target attribute's + * compression method doesn't match that of the source table. */ TupleTableSlot *mt_decompress_tuple_slot; -- 2.17.0 --m51xatjYGsM+13rf Content-Type: text/x-diff; charset=us-ascii Content-Disposition: attachment; filename="v24-0006-alter-table-set-compression.patch" ^ permalink raw reply [nested|flat] 51+ messages in thread
* [PATCH v24 5/7] fixups.patch @ 2021-02-10 21:56 Robert Haas <[email protected]> 0 siblings, 0 replies; 51+ messages in thread From: Robert Haas @ 2021-02-10 21:56 UTC (permalink / raw) --- doc/src/sgml/ddl.sgml | 3 --- doc/src/sgml/ref/create_table.sgml | 15 +++++++++++---- src/backend/access/common/detoast.c | 5 ++--- src/backend/access/compression/compress_lz4.c | 10 +++++----- src/backend/executor/nodeModifyTable.c | 2 +- src/include/nodes/execnodes.h | 4 ++-- 6 files changed, 21 insertions(+), 18 deletions(-) diff --git a/doc/src/sgml/ddl.sgml b/doc/src/sgml/ddl.sgml index 4d7ed698b9..1e9a4625cc 100644 --- a/doc/src/sgml/ddl.sgml +++ b/doc/src/sgml/ddl.sgml @@ -3762,9 +3762,6 @@ CREATE TABLE measurement ( <productname>PostgreSQL</productname> tables (or, possibly, foreign tables). It is possible to specify a tablespace and storage parameters for each partition separately. - By default, each column in a partition inherits the compression method - from parent table's column, however a different compression method can be - set for each partition. </para> <para> diff --git a/doc/src/sgml/ref/create_table.sgml b/doc/src/sgml/ref/create_table.sgml index 51a7a977a5..a4b297340f 100644 --- a/doc/src/sgml/ref/create_table.sgml +++ b/doc/src/sgml/ref/create_table.sgml @@ -997,10 +997,17 @@ WITH ( MODULUS <replaceable class="parameter">numeric_literal</replaceable>, REM <term><literal>COMPRESSION <replaceable class="parameter">compression_method</replaceable></literal></term> <listitem> <para> - This sets the compression method for a column. The supported compression - methods are <literal>pglz</literal> and <literal>lz4</literal>. - <literal>lz4</literal> is available only if <literal>--with-lz4</literal> - was used when building <productname>PostgreSQL</productname>. The default + The <literal>COMPRESSION</literal> clause sets the compression method + for a column. Compression is supported only for variable-width data + types, and is used only for columns whose storage type is main or + extended. (See <xref linkend="sql-altertable"/> for information on + column storage types.) Setting this property for a partitioned table + has no direct effect, because such tables have no storage of their own, + but the configured value is inherited by newly-created partitions. + The supported compression methods are <literal>pglz</literal> and + <literal>lz4</literal>. <literal>lz4</literal> is available only if + <literal>--with-lz4</literal> was used when building + <productname>PostgreSQL</productname>. The default is <literal>pglz</literal>. </para> </listitem> diff --git a/src/backend/access/common/detoast.c b/src/backend/access/common/detoast.c index b78d49167b..95d5b1c12a 100644 --- a/src/backend/access/common/detoast.c +++ b/src/backend/access/common/detoast.c @@ -477,8 +477,8 @@ toast_get_compression_oid(struct varlena *attr) return InvalidOid; /* - * Just fetch the toast compress header to know the compression method - * in the compressed data. + * Fetch just enough of the value to examine the compression header, + * so that we can find out the compression method. */ attr = toast_fetch_datum_slice(attr, 0, VARHDRSZ_COMPRESS); } @@ -503,7 +503,6 @@ toast_get_compression_handler(struct varlena *attr) cmid = TOAST_COMPRESS_METHOD(attr); - /* Get the handler routines for the compression method */ switch (cmid) { case PGLZ_COMPRESSION_ID: diff --git a/src/backend/access/compression/compress_lz4.c b/src/backend/access/compression/compress_lz4.c index 1856cf7df7..3079eff7eb 100644 --- a/src/backend/access/compression/compress_lz4.c +++ b/src/backend/access/compression/compress_lz4.c @@ -23,7 +23,7 @@ /* * lz4_cmcompress - compression routine for lz4 compression method * - * Compresses source into dest using the default strategy. Returns the + * Compresses source into dest using the LZ4 defaults. Returns the * compressed varlena, or NULL if compression fails. */ static struct varlena * @@ -42,8 +42,8 @@ lz4_cmcompress(const struct varlena *value) valsize = VARSIZE_ANY_EXHDR(value); /* - * Get maximum size of the compressed data that lz4 compression may output - * and allocate the memory for holding the compressed data and the header. + * 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_COMPRESS); @@ -83,10 +83,10 @@ lz4_cmdecompress(const struct varlena *value) int32 rawsize; struct varlena *result; - /* allocate memory for holding the uncompressed data */ + /* allocate memory for the uncompressed data */ result = (struct varlena *) palloc(VARRAWSIZE_4B_C(value) + VARHDRSZ); - /* decompress data using lz4 routine */ + /* decompress the data */ rawsize = LZ4_decompress_safe((char *) value + VARHDRSZ_COMPRESS, VARDATA(result), VARSIZE(value) - VARHDRSZ_COMPRESS, diff --git a/src/backend/executor/nodeModifyTable.c b/src/backend/executor/nodeModifyTable.c index f77deee399..920d9dd0d5 100644 --- a/src/backend/executor/nodeModifyTable.c +++ b/src/backend/executor/nodeModifyTable.c @@ -2117,7 +2117,7 @@ CompareCompressionMethodAndDecompress(TupleTableSlot *slot, TupleTableSlot *newslot = *outslot; /* - * If the called has passed an invalid slot then create a new slot. + * If the caller has passed an invalid slot then create a new slot. * Otherwise, just clear the existing tuple from the slot. This slot * should be stored by the caller so that it can be reused for * decompressing the subsequent tuples. diff --git a/src/include/nodes/execnodes.h b/src/include/nodes/execnodes.h index 18e8ecfd90..d8483c36b3 100644 --- a/src/include/nodes/execnodes.h +++ b/src/include/nodes/execnodes.h @@ -1183,8 +1183,8 @@ typedef struct ModifyTableState TupleTableSlot *mt_root_tuple_slot; /* - * Slot for storing the modified tuple, incase the target attribute's - * compression method doesn't match with the source table. + * Slot for storing the modified tuple, in case the target attribute's + * compression method doesn't match that of the source table. */ TupleTableSlot *mt_decompress_tuple_slot; -- 2.17.0 --YZ5djTAD1cGYuMQK Content-Type: text/x-diff; charset=us-ascii Content-Disposition: attachment; filename="v24-0006-alter-table-set-compression.patch" ^ permalink raw reply [nested|flat] 51+ messages in thread
* [PATCH v24 05/10] fixups.patch @ 2021-02-10 21:56 Robert Haas <[email protected]> 0 siblings, 0 replies; 51+ messages in thread From: Robert Haas @ 2021-02-10 21:56 UTC (permalink / raw) --- doc/src/sgml/ddl.sgml | 3 --- doc/src/sgml/ref/create_table.sgml | 15 +++++++++++---- src/backend/access/common/detoast.c | 5 ++--- src/backend/access/compression/compress_lz4.c | 10 +++++----- src/backend/executor/nodeModifyTable.c | 2 +- src/include/nodes/execnodes.h | 4 ++-- 6 files changed, 21 insertions(+), 18 deletions(-) diff --git a/doc/src/sgml/ddl.sgml b/doc/src/sgml/ddl.sgml index 4d7ed698b9..1e9a4625cc 100644 --- a/doc/src/sgml/ddl.sgml +++ b/doc/src/sgml/ddl.sgml @@ -3762,9 +3762,6 @@ CREATE TABLE measurement ( <productname>PostgreSQL</productname> tables (or, possibly, foreign tables). It is possible to specify a tablespace and storage parameters for each partition separately. - By default, each column in a partition inherits the compression method - from parent table's column, however a different compression method can be - set for each partition. </para> <para> diff --git a/doc/src/sgml/ref/create_table.sgml b/doc/src/sgml/ref/create_table.sgml index 51a7a977a5..a4b297340f 100644 --- a/doc/src/sgml/ref/create_table.sgml +++ b/doc/src/sgml/ref/create_table.sgml @@ -997,10 +997,17 @@ WITH ( MODULUS <replaceable class="parameter">numeric_literal</replaceable>, REM <term><literal>COMPRESSION <replaceable class="parameter">compression_method</replaceable></literal></term> <listitem> <para> - This sets the compression method for a column. The supported compression - methods are <literal>pglz</literal> and <literal>lz4</literal>. - <literal>lz4</literal> is available only if <literal>--with-lz4</literal> - was used when building <productname>PostgreSQL</productname>. The default + The <literal>COMPRESSION</literal> clause sets the compression method + for a column. Compression is supported only for variable-width data + types, and is used only for columns whose storage type is main or + extended. (See <xref linkend="sql-altertable"/> for information on + column storage types.) Setting this property for a partitioned table + has no direct effect, because such tables have no storage of their own, + but the configured value is inherited by newly-created partitions. + The supported compression methods are <literal>pglz</literal> and + <literal>lz4</literal>. <literal>lz4</literal> is available only if + <literal>--with-lz4</literal> was used when building + <productname>PostgreSQL</productname>. The default is <literal>pglz</literal>. </para> </listitem> diff --git a/src/backend/access/common/detoast.c b/src/backend/access/common/detoast.c index b78d49167b..95d5b1c12a 100644 --- a/src/backend/access/common/detoast.c +++ b/src/backend/access/common/detoast.c @@ -477,8 +477,8 @@ toast_get_compression_oid(struct varlena *attr) return InvalidOid; /* - * Just fetch the toast compress header to know the compression method - * in the compressed data. + * Fetch just enough of the value to examine the compression header, + * so that we can find out the compression method. */ attr = toast_fetch_datum_slice(attr, 0, VARHDRSZ_COMPRESS); } @@ -503,7 +503,6 @@ toast_get_compression_handler(struct varlena *attr) cmid = TOAST_COMPRESS_METHOD(attr); - /* Get the handler routines for the compression method */ switch (cmid) { case PGLZ_COMPRESSION_ID: diff --git a/src/backend/access/compression/compress_lz4.c b/src/backend/access/compression/compress_lz4.c index 1856cf7df7..3079eff7eb 100644 --- a/src/backend/access/compression/compress_lz4.c +++ b/src/backend/access/compression/compress_lz4.c @@ -23,7 +23,7 @@ /* * lz4_cmcompress - compression routine for lz4 compression method * - * Compresses source into dest using the default strategy. Returns the + * Compresses source into dest using the LZ4 defaults. Returns the * compressed varlena, or NULL if compression fails. */ static struct varlena * @@ -42,8 +42,8 @@ lz4_cmcompress(const struct varlena *value) valsize = VARSIZE_ANY_EXHDR(value); /* - * Get maximum size of the compressed data that lz4 compression may output - * and allocate the memory for holding the compressed data and the header. + * 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_COMPRESS); @@ -83,10 +83,10 @@ lz4_cmdecompress(const struct varlena *value) int32 rawsize; struct varlena *result; - /* allocate memory for holding the uncompressed data */ + /* allocate memory for the uncompressed data */ result = (struct varlena *) palloc(VARRAWSIZE_4B_C(value) + VARHDRSZ); - /* decompress data using lz4 routine */ + /* decompress the data */ rawsize = LZ4_decompress_safe((char *) value + VARHDRSZ_COMPRESS, VARDATA(result), VARSIZE(value) - VARHDRSZ_COMPRESS, diff --git a/src/backend/executor/nodeModifyTable.c b/src/backend/executor/nodeModifyTable.c index f77deee399..920d9dd0d5 100644 --- a/src/backend/executor/nodeModifyTable.c +++ b/src/backend/executor/nodeModifyTable.c @@ -2117,7 +2117,7 @@ CompareCompressionMethodAndDecompress(TupleTableSlot *slot, TupleTableSlot *newslot = *outslot; /* - * If the called has passed an invalid slot then create a new slot. + * If the caller has passed an invalid slot then create a new slot. * Otherwise, just clear the existing tuple from the slot. This slot * should be stored by the caller so that it can be reused for * decompressing the subsequent tuples. diff --git a/src/include/nodes/execnodes.h b/src/include/nodes/execnodes.h index 18e8ecfd90..d8483c36b3 100644 --- a/src/include/nodes/execnodes.h +++ b/src/include/nodes/execnodes.h @@ -1183,8 +1183,8 @@ typedef struct ModifyTableState TupleTableSlot *mt_root_tuple_slot; /* - * Slot for storing the modified tuple, incase the target attribute's - * compression method doesn't match with the source table. + * Slot for storing the modified tuple, in case the target attribute's + * compression method doesn't match that of the source table. */ TupleTableSlot *mt_decompress_tuple_slot; -- 2.17.0 --m51xatjYGsM+13rf Content-Type: text/x-diff; charset=us-ascii Content-Disposition: attachment; filename="v24-0006-alter-table-set-compression.patch" ^ permalink raw reply [nested|flat] 51+ messages in thread
* [PATCH v24 5/7] fixups.patch @ 2021-02-10 21:56 Robert Haas <[email protected]> 0 siblings, 0 replies; 51+ messages in thread From: Robert Haas @ 2021-02-10 21:56 UTC (permalink / raw) --- doc/src/sgml/ddl.sgml | 3 --- doc/src/sgml/ref/create_table.sgml | 15 +++++++++++---- src/backend/access/common/detoast.c | 5 ++--- src/backend/access/compression/compress_lz4.c | 10 +++++----- src/backend/executor/nodeModifyTable.c | 2 +- src/include/nodes/execnodes.h | 4 ++-- 6 files changed, 21 insertions(+), 18 deletions(-) diff --git a/doc/src/sgml/ddl.sgml b/doc/src/sgml/ddl.sgml index 4d7ed698b9..1e9a4625cc 100644 --- a/doc/src/sgml/ddl.sgml +++ b/doc/src/sgml/ddl.sgml @@ -3762,9 +3762,6 @@ CREATE TABLE measurement ( <productname>PostgreSQL</productname> tables (or, possibly, foreign tables). It is possible to specify a tablespace and storage parameters for each partition separately. - By default, each column in a partition inherits the compression method - from parent table's column, however a different compression method can be - set for each partition. </para> <para> diff --git a/doc/src/sgml/ref/create_table.sgml b/doc/src/sgml/ref/create_table.sgml index 51a7a977a5..a4b297340f 100644 --- a/doc/src/sgml/ref/create_table.sgml +++ b/doc/src/sgml/ref/create_table.sgml @@ -997,10 +997,17 @@ WITH ( MODULUS <replaceable class="parameter">numeric_literal</replaceable>, REM <term><literal>COMPRESSION <replaceable class="parameter">compression_method</replaceable></literal></term> <listitem> <para> - This sets the compression method for a column. The supported compression - methods are <literal>pglz</literal> and <literal>lz4</literal>. - <literal>lz4</literal> is available only if <literal>--with-lz4</literal> - was used when building <productname>PostgreSQL</productname>. The default + The <literal>COMPRESSION</literal> clause sets the compression method + for a column. Compression is supported only for variable-width data + types, and is used only for columns whose storage type is main or + extended. (See <xref linkend="sql-altertable"/> for information on + column storage types.) Setting this property for a partitioned table + has no direct effect, because such tables have no storage of their own, + but the configured value is inherited by newly-created partitions. + The supported compression methods are <literal>pglz</literal> and + <literal>lz4</literal>. <literal>lz4</literal> is available only if + <literal>--with-lz4</literal> was used when building + <productname>PostgreSQL</productname>. The default is <literal>pglz</literal>. </para> </listitem> diff --git a/src/backend/access/common/detoast.c b/src/backend/access/common/detoast.c index b78d49167b..95d5b1c12a 100644 --- a/src/backend/access/common/detoast.c +++ b/src/backend/access/common/detoast.c @@ -477,8 +477,8 @@ toast_get_compression_oid(struct varlena *attr) return InvalidOid; /* - * Just fetch the toast compress header to know the compression method - * in the compressed data. + * Fetch just enough of the value to examine the compression header, + * so that we can find out the compression method. */ attr = toast_fetch_datum_slice(attr, 0, VARHDRSZ_COMPRESS); } @@ -503,7 +503,6 @@ toast_get_compression_handler(struct varlena *attr) cmid = TOAST_COMPRESS_METHOD(attr); - /* Get the handler routines for the compression method */ switch (cmid) { case PGLZ_COMPRESSION_ID: diff --git a/src/backend/access/compression/compress_lz4.c b/src/backend/access/compression/compress_lz4.c index 1856cf7df7..3079eff7eb 100644 --- a/src/backend/access/compression/compress_lz4.c +++ b/src/backend/access/compression/compress_lz4.c @@ -23,7 +23,7 @@ /* * lz4_cmcompress - compression routine for lz4 compression method * - * Compresses source into dest using the default strategy. Returns the + * Compresses source into dest using the LZ4 defaults. Returns the * compressed varlena, or NULL if compression fails. */ static struct varlena * @@ -42,8 +42,8 @@ lz4_cmcompress(const struct varlena *value) valsize = VARSIZE_ANY_EXHDR(value); /* - * Get maximum size of the compressed data that lz4 compression may output - * and allocate the memory for holding the compressed data and the header. + * 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_COMPRESS); @@ -83,10 +83,10 @@ lz4_cmdecompress(const struct varlena *value) int32 rawsize; struct varlena *result; - /* allocate memory for holding the uncompressed data */ + /* allocate memory for the uncompressed data */ result = (struct varlena *) palloc(VARRAWSIZE_4B_C(value) + VARHDRSZ); - /* decompress data using lz4 routine */ + /* decompress the data */ rawsize = LZ4_decompress_safe((char *) value + VARHDRSZ_COMPRESS, VARDATA(result), VARSIZE(value) - VARHDRSZ_COMPRESS, diff --git a/src/backend/executor/nodeModifyTable.c b/src/backend/executor/nodeModifyTable.c index f77deee399..920d9dd0d5 100644 --- a/src/backend/executor/nodeModifyTable.c +++ b/src/backend/executor/nodeModifyTable.c @@ -2117,7 +2117,7 @@ CompareCompressionMethodAndDecompress(TupleTableSlot *slot, TupleTableSlot *newslot = *outslot; /* - * If the called has passed an invalid slot then create a new slot. + * If the caller has passed an invalid slot then create a new slot. * Otherwise, just clear the existing tuple from the slot. This slot * should be stored by the caller so that it can be reused for * decompressing the subsequent tuples. diff --git a/src/include/nodes/execnodes.h b/src/include/nodes/execnodes.h index 18e8ecfd90..d8483c36b3 100644 --- a/src/include/nodes/execnodes.h +++ b/src/include/nodes/execnodes.h @@ -1183,8 +1183,8 @@ typedef struct ModifyTableState TupleTableSlot *mt_root_tuple_slot; /* - * Slot for storing the modified tuple, incase the target attribute's - * compression method doesn't match with the source table. + * Slot for storing the modified tuple, in case the target attribute's + * compression method doesn't match that of the source table. */ TupleTableSlot *mt_decompress_tuple_slot; -- 2.17.0 --YZ5djTAD1cGYuMQK Content-Type: text/x-diff; charset=us-ascii Content-Disposition: attachment; filename="v24-0006-alter-table-set-compression.patch" ^ permalink raw reply [nested|flat] 51+ messages in thread
* [PATCH v24 05/10] fixups.patch @ 2021-02-10 21:56 Robert Haas <[email protected]> 0 siblings, 0 replies; 51+ messages in thread From: Robert Haas @ 2021-02-10 21:56 UTC (permalink / raw) --- doc/src/sgml/ddl.sgml | 3 --- doc/src/sgml/ref/create_table.sgml | 15 +++++++++++---- src/backend/access/common/detoast.c | 5 ++--- src/backend/access/compression/compress_lz4.c | 10 +++++----- src/backend/executor/nodeModifyTable.c | 2 +- src/include/nodes/execnodes.h | 4 ++-- 6 files changed, 21 insertions(+), 18 deletions(-) diff --git a/doc/src/sgml/ddl.sgml b/doc/src/sgml/ddl.sgml index 4d7ed698b9..1e9a4625cc 100644 --- a/doc/src/sgml/ddl.sgml +++ b/doc/src/sgml/ddl.sgml @@ -3762,9 +3762,6 @@ CREATE TABLE measurement ( <productname>PostgreSQL</productname> tables (or, possibly, foreign tables). It is possible to specify a tablespace and storage parameters for each partition separately. - By default, each column in a partition inherits the compression method - from parent table's column, however a different compression method can be - set for each partition. </para> <para> diff --git a/doc/src/sgml/ref/create_table.sgml b/doc/src/sgml/ref/create_table.sgml index 51a7a977a5..a4b297340f 100644 --- a/doc/src/sgml/ref/create_table.sgml +++ b/doc/src/sgml/ref/create_table.sgml @@ -997,10 +997,17 @@ WITH ( MODULUS <replaceable class="parameter">numeric_literal</replaceable>, REM <term><literal>COMPRESSION <replaceable class="parameter">compression_method</replaceable></literal></term> <listitem> <para> - This sets the compression method for a column. The supported compression - methods are <literal>pglz</literal> and <literal>lz4</literal>. - <literal>lz4</literal> is available only if <literal>--with-lz4</literal> - was used when building <productname>PostgreSQL</productname>. The default + The <literal>COMPRESSION</literal> clause sets the compression method + for a column. Compression is supported only for variable-width data + types, and is used only for columns whose storage type is main or + extended. (See <xref linkend="sql-altertable"/> for information on + column storage types.) Setting this property for a partitioned table + has no direct effect, because such tables have no storage of their own, + but the configured value is inherited by newly-created partitions. + The supported compression methods are <literal>pglz</literal> and + <literal>lz4</literal>. <literal>lz4</literal> is available only if + <literal>--with-lz4</literal> was used when building + <productname>PostgreSQL</productname>. The default is <literal>pglz</literal>. </para> </listitem> diff --git a/src/backend/access/common/detoast.c b/src/backend/access/common/detoast.c index b78d49167b..95d5b1c12a 100644 --- a/src/backend/access/common/detoast.c +++ b/src/backend/access/common/detoast.c @@ -477,8 +477,8 @@ toast_get_compression_oid(struct varlena *attr) return InvalidOid; /* - * Just fetch the toast compress header to know the compression method - * in the compressed data. + * Fetch just enough of the value to examine the compression header, + * so that we can find out the compression method. */ attr = toast_fetch_datum_slice(attr, 0, VARHDRSZ_COMPRESS); } @@ -503,7 +503,6 @@ toast_get_compression_handler(struct varlena *attr) cmid = TOAST_COMPRESS_METHOD(attr); - /* Get the handler routines for the compression method */ switch (cmid) { case PGLZ_COMPRESSION_ID: diff --git a/src/backend/access/compression/compress_lz4.c b/src/backend/access/compression/compress_lz4.c index 1856cf7df7..3079eff7eb 100644 --- a/src/backend/access/compression/compress_lz4.c +++ b/src/backend/access/compression/compress_lz4.c @@ -23,7 +23,7 @@ /* * lz4_cmcompress - compression routine for lz4 compression method * - * Compresses source into dest using the default strategy. Returns the + * Compresses source into dest using the LZ4 defaults. Returns the * compressed varlena, or NULL if compression fails. */ static struct varlena * @@ -42,8 +42,8 @@ lz4_cmcompress(const struct varlena *value) valsize = VARSIZE_ANY_EXHDR(value); /* - * Get maximum size of the compressed data that lz4 compression may output - * and allocate the memory for holding the compressed data and the header. + * 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_COMPRESS); @@ -83,10 +83,10 @@ lz4_cmdecompress(const struct varlena *value) int32 rawsize; struct varlena *result; - /* allocate memory for holding the uncompressed data */ + /* allocate memory for the uncompressed data */ result = (struct varlena *) palloc(VARRAWSIZE_4B_C(value) + VARHDRSZ); - /* decompress data using lz4 routine */ + /* decompress the data */ rawsize = LZ4_decompress_safe((char *) value + VARHDRSZ_COMPRESS, VARDATA(result), VARSIZE(value) - VARHDRSZ_COMPRESS, diff --git a/src/backend/executor/nodeModifyTable.c b/src/backend/executor/nodeModifyTable.c index f77deee399..920d9dd0d5 100644 --- a/src/backend/executor/nodeModifyTable.c +++ b/src/backend/executor/nodeModifyTable.c @@ -2117,7 +2117,7 @@ CompareCompressionMethodAndDecompress(TupleTableSlot *slot, TupleTableSlot *newslot = *outslot; /* - * If the called has passed an invalid slot then create a new slot. + * If the caller has passed an invalid slot then create a new slot. * Otherwise, just clear the existing tuple from the slot. This slot * should be stored by the caller so that it can be reused for * decompressing the subsequent tuples. diff --git a/src/include/nodes/execnodes.h b/src/include/nodes/execnodes.h index 18e8ecfd90..d8483c36b3 100644 --- a/src/include/nodes/execnodes.h +++ b/src/include/nodes/execnodes.h @@ -1183,8 +1183,8 @@ typedef struct ModifyTableState TupleTableSlot *mt_root_tuple_slot; /* - * Slot for storing the modified tuple, incase the target attribute's - * compression method doesn't match with the source table. + * Slot for storing the modified tuple, in case the target attribute's + * compression method doesn't match that of the source table. */ TupleTableSlot *mt_decompress_tuple_slot; -- 2.17.0 --m51xatjYGsM+13rf Content-Type: text/x-diff; charset=us-ascii Content-Disposition: attachment; filename="v24-0006-alter-table-set-compression.patch" ^ permalink raw reply [nested|flat] 51+ messages in thread
* [PATCH v24 5/7] fixups.patch @ 2021-02-10 21:56 Robert Haas <[email protected]> 0 siblings, 0 replies; 51+ messages in thread From: Robert Haas @ 2021-02-10 21:56 UTC (permalink / raw) --- doc/src/sgml/ddl.sgml | 3 --- doc/src/sgml/ref/create_table.sgml | 15 +++++++++++---- src/backend/access/common/detoast.c | 5 ++--- src/backend/access/compression/compress_lz4.c | 10 +++++----- src/backend/executor/nodeModifyTable.c | 2 +- src/include/nodes/execnodes.h | 4 ++-- 6 files changed, 21 insertions(+), 18 deletions(-) diff --git a/doc/src/sgml/ddl.sgml b/doc/src/sgml/ddl.sgml index 4d7ed698b9..1e9a4625cc 100644 --- a/doc/src/sgml/ddl.sgml +++ b/doc/src/sgml/ddl.sgml @@ -3762,9 +3762,6 @@ CREATE TABLE measurement ( <productname>PostgreSQL</productname> tables (or, possibly, foreign tables). It is possible to specify a tablespace and storage parameters for each partition separately. - By default, each column in a partition inherits the compression method - from parent table's column, however a different compression method can be - set for each partition. </para> <para> diff --git a/doc/src/sgml/ref/create_table.sgml b/doc/src/sgml/ref/create_table.sgml index 51a7a977a5..a4b297340f 100644 --- a/doc/src/sgml/ref/create_table.sgml +++ b/doc/src/sgml/ref/create_table.sgml @@ -997,10 +997,17 @@ WITH ( MODULUS <replaceable class="parameter">numeric_literal</replaceable>, REM <term><literal>COMPRESSION <replaceable class="parameter">compression_method</replaceable></literal></term> <listitem> <para> - This sets the compression method for a column. The supported compression - methods are <literal>pglz</literal> and <literal>lz4</literal>. - <literal>lz4</literal> is available only if <literal>--with-lz4</literal> - was used when building <productname>PostgreSQL</productname>. The default + The <literal>COMPRESSION</literal> clause sets the compression method + for a column. Compression is supported only for variable-width data + types, and is used only for columns whose storage type is main or + extended. (See <xref linkend="sql-altertable"/> for information on + column storage types.) Setting this property for a partitioned table + has no direct effect, because such tables have no storage of their own, + but the configured value is inherited by newly-created partitions. + The supported compression methods are <literal>pglz</literal> and + <literal>lz4</literal>. <literal>lz4</literal> is available only if + <literal>--with-lz4</literal> was used when building + <productname>PostgreSQL</productname>. The default is <literal>pglz</literal>. </para> </listitem> diff --git a/src/backend/access/common/detoast.c b/src/backend/access/common/detoast.c index b78d49167b..95d5b1c12a 100644 --- a/src/backend/access/common/detoast.c +++ b/src/backend/access/common/detoast.c @@ -477,8 +477,8 @@ toast_get_compression_oid(struct varlena *attr) return InvalidOid; /* - * Just fetch the toast compress header to know the compression method - * in the compressed data. + * Fetch just enough of the value to examine the compression header, + * so that we can find out the compression method. */ attr = toast_fetch_datum_slice(attr, 0, VARHDRSZ_COMPRESS); } @@ -503,7 +503,6 @@ toast_get_compression_handler(struct varlena *attr) cmid = TOAST_COMPRESS_METHOD(attr); - /* Get the handler routines for the compression method */ switch (cmid) { case PGLZ_COMPRESSION_ID: diff --git a/src/backend/access/compression/compress_lz4.c b/src/backend/access/compression/compress_lz4.c index 1856cf7df7..3079eff7eb 100644 --- a/src/backend/access/compression/compress_lz4.c +++ b/src/backend/access/compression/compress_lz4.c @@ -23,7 +23,7 @@ /* * lz4_cmcompress - compression routine for lz4 compression method * - * Compresses source into dest using the default strategy. Returns the + * Compresses source into dest using the LZ4 defaults. Returns the * compressed varlena, or NULL if compression fails. */ static struct varlena * @@ -42,8 +42,8 @@ lz4_cmcompress(const struct varlena *value) valsize = VARSIZE_ANY_EXHDR(value); /* - * Get maximum size of the compressed data that lz4 compression may output - * and allocate the memory for holding the compressed data and the header. + * 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_COMPRESS); @@ -83,10 +83,10 @@ lz4_cmdecompress(const struct varlena *value) int32 rawsize; struct varlena *result; - /* allocate memory for holding the uncompressed data */ + /* allocate memory for the uncompressed data */ result = (struct varlena *) palloc(VARRAWSIZE_4B_C(value) + VARHDRSZ); - /* decompress data using lz4 routine */ + /* decompress the data */ rawsize = LZ4_decompress_safe((char *) value + VARHDRSZ_COMPRESS, VARDATA(result), VARSIZE(value) - VARHDRSZ_COMPRESS, diff --git a/src/backend/executor/nodeModifyTable.c b/src/backend/executor/nodeModifyTable.c index f77deee399..920d9dd0d5 100644 --- a/src/backend/executor/nodeModifyTable.c +++ b/src/backend/executor/nodeModifyTable.c @@ -2117,7 +2117,7 @@ CompareCompressionMethodAndDecompress(TupleTableSlot *slot, TupleTableSlot *newslot = *outslot; /* - * If the called has passed an invalid slot then create a new slot. + * If the caller has passed an invalid slot then create a new slot. * Otherwise, just clear the existing tuple from the slot. This slot * should be stored by the caller so that it can be reused for * decompressing the subsequent tuples. diff --git a/src/include/nodes/execnodes.h b/src/include/nodes/execnodes.h index 18e8ecfd90..d8483c36b3 100644 --- a/src/include/nodes/execnodes.h +++ b/src/include/nodes/execnodes.h @@ -1183,8 +1183,8 @@ typedef struct ModifyTableState TupleTableSlot *mt_root_tuple_slot; /* - * Slot for storing the modified tuple, incase the target attribute's - * compression method doesn't match with the source table. + * Slot for storing the modified tuple, in case the target attribute's + * compression method doesn't match that of the source table. */ TupleTableSlot *mt_decompress_tuple_slot; -- 2.17.0 --YZ5djTAD1cGYuMQK Content-Type: text/x-diff; charset=us-ascii Content-Disposition: attachment; filename="v24-0006-alter-table-set-compression.patch" ^ permalink raw reply [nested|flat] 51+ messages in thread
* [PATCH v24 05/10] fixups.patch @ 2021-02-10 21:56 Robert Haas <[email protected]> 0 siblings, 0 replies; 51+ messages in thread From: Robert Haas @ 2021-02-10 21:56 UTC (permalink / raw) --- doc/src/sgml/ddl.sgml | 3 --- doc/src/sgml/ref/create_table.sgml | 15 +++++++++++---- src/backend/access/common/detoast.c | 5 ++--- src/backend/access/compression/compress_lz4.c | 10 +++++----- src/backend/executor/nodeModifyTable.c | 2 +- src/include/nodes/execnodes.h | 4 ++-- 6 files changed, 21 insertions(+), 18 deletions(-) diff --git a/doc/src/sgml/ddl.sgml b/doc/src/sgml/ddl.sgml index 4d7ed698b9..1e9a4625cc 100644 --- a/doc/src/sgml/ddl.sgml +++ b/doc/src/sgml/ddl.sgml @@ -3762,9 +3762,6 @@ CREATE TABLE measurement ( <productname>PostgreSQL</productname> tables (or, possibly, foreign tables). It is possible to specify a tablespace and storage parameters for each partition separately. - By default, each column in a partition inherits the compression method - from parent table's column, however a different compression method can be - set for each partition. </para> <para> diff --git a/doc/src/sgml/ref/create_table.sgml b/doc/src/sgml/ref/create_table.sgml index 51a7a977a5..a4b297340f 100644 --- a/doc/src/sgml/ref/create_table.sgml +++ b/doc/src/sgml/ref/create_table.sgml @@ -997,10 +997,17 @@ WITH ( MODULUS <replaceable class="parameter">numeric_literal</replaceable>, REM <term><literal>COMPRESSION <replaceable class="parameter">compression_method</replaceable></literal></term> <listitem> <para> - This sets the compression method for a column. The supported compression - methods are <literal>pglz</literal> and <literal>lz4</literal>. - <literal>lz4</literal> is available only if <literal>--with-lz4</literal> - was used when building <productname>PostgreSQL</productname>. The default + The <literal>COMPRESSION</literal> clause sets the compression method + for a column. Compression is supported only for variable-width data + types, and is used only for columns whose storage type is main or + extended. (See <xref linkend="sql-altertable"/> for information on + column storage types.) Setting this property for a partitioned table + has no direct effect, because such tables have no storage of their own, + but the configured value is inherited by newly-created partitions. + The supported compression methods are <literal>pglz</literal> and + <literal>lz4</literal>. <literal>lz4</literal> is available only if + <literal>--with-lz4</literal> was used when building + <productname>PostgreSQL</productname>. The default is <literal>pglz</literal>. </para> </listitem> diff --git a/src/backend/access/common/detoast.c b/src/backend/access/common/detoast.c index b78d49167b..95d5b1c12a 100644 --- a/src/backend/access/common/detoast.c +++ b/src/backend/access/common/detoast.c @@ -477,8 +477,8 @@ toast_get_compression_oid(struct varlena *attr) return InvalidOid; /* - * Just fetch the toast compress header to know the compression method - * in the compressed data. + * Fetch just enough of the value to examine the compression header, + * so that we can find out the compression method. */ attr = toast_fetch_datum_slice(attr, 0, VARHDRSZ_COMPRESS); } @@ -503,7 +503,6 @@ toast_get_compression_handler(struct varlena *attr) cmid = TOAST_COMPRESS_METHOD(attr); - /* Get the handler routines for the compression method */ switch (cmid) { case PGLZ_COMPRESSION_ID: diff --git a/src/backend/access/compression/compress_lz4.c b/src/backend/access/compression/compress_lz4.c index 1856cf7df7..3079eff7eb 100644 --- a/src/backend/access/compression/compress_lz4.c +++ b/src/backend/access/compression/compress_lz4.c @@ -23,7 +23,7 @@ /* * lz4_cmcompress - compression routine for lz4 compression method * - * Compresses source into dest using the default strategy. Returns the + * Compresses source into dest using the LZ4 defaults. Returns the * compressed varlena, or NULL if compression fails. */ static struct varlena * @@ -42,8 +42,8 @@ lz4_cmcompress(const struct varlena *value) valsize = VARSIZE_ANY_EXHDR(value); /* - * Get maximum size of the compressed data that lz4 compression may output - * and allocate the memory for holding the compressed data and the header. + * 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_COMPRESS); @@ -83,10 +83,10 @@ lz4_cmdecompress(const struct varlena *value) int32 rawsize; struct varlena *result; - /* allocate memory for holding the uncompressed data */ + /* allocate memory for the uncompressed data */ result = (struct varlena *) palloc(VARRAWSIZE_4B_C(value) + VARHDRSZ); - /* decompress data using lz4 routine */ + /* decompress the data */ rawsize = LZ4_decompress_safe((char *) value + VARHDRSZ_COMPRESS, VARDATA(result), VARSIZE(value) - VARHDRSZ_COMPRESS, diff --git a/src/backend/executor/nodeModifyTable.c b/src/backend/executor/nodeModifyTable.c index f77deee399..920d9dd0d5 100644 --- a/src/backend/executor/nodeModifyTable.c +++ b/src/backend/executor/nodeModifyTable.c @@ -2117,7 +2117,7 @@ CompareCompressionMethodAndDecompress(TupleTableSlot *slot, TupleTableSlot *newslot = *outslot; /* - * If the called has passed an invalid slot then create a new slot. + * If the caller has passed an invalid slot then create a new slot. * Otherwise, just clear the existing tuple from the slot. This slot * should be stored by the caller so that it can be reused for * decompressing the subsequent tuples. diff --git a/src/include/nodes/execnodes.h b/src/include/nodes/execnodes.h index 18e8ecfd90..d8483c36b3 100644 --- a/src/include/nodes/execnodes.h +++ b/src/include/nodes/execnodes.h @@ -1183,8 +1183,8 @@ typedef struct ModifyTableState TupleTableSlot *mt_root_tuple_slot; /* - * Slot for storing the modified tuple, incase the target attribute's - * compression method doesn't match with the source table. + * Slot for storing the modified tuple, in case the target attribute's + * compression method doesn't match that of the source table. */ TupleTableSlot *mt_decompress_tuple_slot; -- 2.17.0 --m51xatjYGsM+13rf Content-Type: text/x-diff; charset=us-ascii Content-Disposition: attachment; filename="v24-0006-alter-table-set-compression.patch" ^ permalink raw reply [nested|flat] 51+ messages in thread
* [PATCH v24 5/7] fixups.patch @ 2021-02-10 21:56 Robert Haas <[email protected]> 0 siblings, 0 replies; 51+ messages in thread From: Robert Haas @ 2021-02-10 21:56 UTC (permalink / raw) --- doc/src/sgml/ddl.sgml | 3 --- doc/src/sgml/ref/create_table.sgml | 15 +++++++++++---- src/backend/access/common/detoast.c | 5 ++--- src/backend/access/compression/compress_lz4.c | 10 +++++----- src/backend/executor/nodeModifyTable.c | 2 +- src/include/nodes/execnodes.h | 4 ++-- 6 files changed, 21 insertions(+), 18 deletions(-) diff --git a/doc/src/sgml/ddl.sgml b/doc/src/sgml/ddl.sgml index 4d7ed698b9..1e9a4625cc 100644 --- a/doc/src/sgml/ddl.sgml +++ b/doc/src/sgml/ddl.sgml @@ -3762,9 +3762,6 @@ CREATE TABLE measurement ( <productname>PostgreSQL</productname> tables (or, possibly, foreign tables). It is possible to specify a tablespace and storage parameters for each partition separately. - By default, each column in a partition inherits the compression method - from parent table's column, however a different compression method can be - set for each partition. </para> <para> diff --git a/doc/src/sgml/ref/create_table.sgml b/doc/src/sgml/ref/create_table.sgml index 51a7a977a5..a4b297340f 100644 --- a/doc/src/sgml/ref/create_table.sgml +++ b/doc/src/sgml/ref/create_table.sgml @@ -997,10 +997,17 @@ WITH ( MODULUS <replaceable class="parameter">numeric_literal</replaceable>, REM <term><literal>COMPRESSION <replaceable class="parameter">compression_method</replaceable></literal></term> <listitem> <para> - This sets the compression method for a column. The supported compression - methods are <literal>pglz</literal> and <literal>lz4</literal>. - <literal>lz4</literal> is available only if <literal>--with-lz4</literal> - was used when building <productname>PostgreSQL</productname>. The default + The <literal>COMPRESSION</literal> clause sets the compression method + for a column. Compression is supported only for variable-width data + types, and is used only for columns whose storage type is main or + extended. (See <xref linkend="sql-altertable"/> for information on + column storage types.) Setting this property for a partitioned table + has no direct effect, because such tables have no storage of their own, + but the configured value is inherited by newly-created partitions. + The supported compression methods are <literal>pglz</literal> and + <literal>lz4</literal>. <literal>lz4</literal> is available only if + <literal>--with-lz4</literal> was used when building + <productname>PostgreSQL</productname>. The default is <literal>pglz</literal>. </para> </listitem> diff --git a/src/backend/access/common/detoast.c b/src/backend/access/common/detoast.c index b78d49167b..95d5b1c12a 100644 --- a/src/backend/access/common/detoast.c +++ b/src/backend/access/common/detoast.c @@ -477,8 +477,8 @@ toast_get_compression_oid(struct varlena *attr) return InvalidOid; /* - * Just fetch the toast compress header to know the compression method - * in the compressed data. + * Fetch just enough of the value to examine the compression header, + * so that we can find out the compression method. */ attr = toast_fetch_datum_slice(attr, 0, VARHDRSZ_COMPRESS); } @@ -503,7 +503,6 @@ toast_get_compression_handler(struct varlena *attr) cmid = TOAST_COMPRESS_METHOD(attr); - /* Get the handler routines for the compression method */ switch (cmid) { case PGLZ_COMPRESSION_ID: diff --git a/src/backend/access/compression/compress_lz4.c b/src/backend/access/compression/compress_lz4.c index 1856cf7df7..3079eff7eb 100644 --- a/src/backend/access/compression/compress_lz4.c +++ b/src/backend/access/compression/compress_lz4.c @@ -23,7 +23,7 @@ /* * lz4_cmcompress - compression routine for lz4 compression method * - * Compresses source into dest using the default strategy. Returns the + * Compresses source into dest using the LZ4 defaults. Returns the * compressed varlena, or NULL if compression fails. */ static struct varlena * @@ -42,8 +42,8 @@ lz4_cmcompress(const struct varlena *value) valsize = VARSIZE_ANY_EXHDR(value); /* - * Get maximum size of the compressed data that lz4 compression may output - * and allocate the memory for holding the compressed data and the header. + * 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_COMPRESS); @@ -83,10 +83,10 @@ lz4_cmdecompress(const struct varlena *value) int32 rawsize; struct varlena *result; - /* allocate memory for holding the uncompressed data */ + /* allocate memory for the uncompressed data */ result = (struct varlena *) palloc(VARRAWSIZE_4B_C(value) + VARHDRSZ); - /* decompress data using lz4 routine */ + /* decompress the data */ rawsize = LZ4_decompress_safe((char *) value + VARHDRSZ_COMPRESS, VARDATA(result), VARSIZE(value) - VARHDRSZ_COMPRESS, diff --git a/src/backend/executor/nodeModifyTable.c b/src/backend/executor/nodeModifyTable.c index f77deee399..920d9dd0d5 100644 --- a/src/backend/executor/nodeModifyTable.c +++ b/src/backend/executor/nodeModifyTable.c @@ -2117,7 +2117,7 @@ CompareCompressionMethodAndDecompress(TupleTableSlot *slot, TupleTableSlot *newslot = *outslot; /* - * If the called has passed an invalid slot then create a new slot. + * If the caller has passed an invalid slot then create a new slot. * Otherwise, just clear the existing tuple from the slot. This slot * should be stored by the caller so that it can be reused for * decompressing the subsequent tuples. diff --git a/src/include/nodes/execnodes.h b/src/include/nodes/execnodes.h index 18e8ecfd90..d8483c36b3 100644 --- a/src/include/nodes/execnodes.h +++ b/src/include/nodes/execnodes.h @@ -1183,8 +1183,8 @@ typedef struct ModifyTableState TupleTableSlot *mt_root_tuple_slot; /* - * Slot for storing the modified tuple, incase the target attribute's - * compression method doesn't match with the source table. + * Slot for storing the modified tuple, in case the target attribute's + * compression method doesn't match that of the source table. */ TupleTableSlot *mt_decompress_tuple_slot; -- 2.17.0 --YZ5djTAD1cGYuMQK Content-Type: text/x-diff; charset=us-ascii Content-Disposition: attachment; filename="v24-0006-alter-table-set-compression.patch" ^ permalink raw reply [nested|flat] 51+ messages in thread
* [PATCH v24 05/10] fixups.patch @ 2021-02-10 21:56 Robert Haas <[email protected]> 0 siblings, 0 replies; 51+ messages in thread From: Robert Haas @ 2021-02-10 21:56 UTC (permalink / raw) --- doc/src/sgml/ddl.sgml | 3 --- doc/src/sgml/ref/create_table.sgml | 15 +++++++++++---- src/backend/access/common/detoast.c | 5 ++--- src/backend/access/compression/compress_lz4.c | 10 +++++----- src/backend/executor/nodeModifyTable.c | 2 +- src/include/nodes/execnodes.h | 4 ++-- 6 files changed, 21 insertions(+), 18 deletions(-) diff --git a/doc/src/sgml/ddl.sgml b/doc/src/sgml/ddl.sgml index 4d7ed698b9..1e9a4625cc 100644 --- a/doc/src/sgml/ddl.sgml +++ b/doc/src/sgml/ddl.sgml @@ -3762,9 +3762,6 @@ CREATE TABLE measurement ( <productname>PostgreSQL</productname> tables (or, possibly, foreign tables). It is possible to specify a tablespace and storage parameters for each partition separately. - By default, each column in a partition inherits the compression method - from parent table's column, however a different compression method can be - set for each partition. </para> <para> diff --git a/doc/src/sgml/ref/create_table.sgml b/doc/src/sgml/ref/create_table.sgml index 51a7a977a5..a4b297340f 100644 --- a/doc/src/sgml/ref/create_table.sgml +++ b/doc/src/sgml/ref/create_table.sgml @@ -997,10 +997,17 @@ WITH ( MODULUS <replaceable class="parameter">numeric_literal</replaceable>, REM <term><literal>COMPRESSION <replaceable class="parameter">compression_method</replaceable></literal></term> <listitem> <para> - This sets the compression method for a column. The supported compression - methods are <literal>pglz</literal> and <literal>lz4</literal>. - <literal>lz4</literal> is available only if <literal>--with-lz4</literal> - was used when building <productname>PostgreSQL</productname>. The default + The <literal>COMPRESSION</literal> clause sets the compression method + for a column. Compression is supported only for variable-width data + types, and is used only for columns whose storage type is main or + extended. (See <xref linkend="sql-altertable"/> for information on + column storage types.) Setting this property for a partitioned table + has no direct effect, because such tables have no storage of their own, + but the configured value is inherited by newly-created partitions. + The supported compression methods are <literal>pglz</literal> and + <literal>lz4</literal>. <literal>lz4</literal> is available only if + <literal>--with-lz4</literal> was used when building + <productname>PostgreSQL</productname>. The default is <literal>pglz</literal>. </para> </listitem> diff --git a/src/backend/access/common/detoast.c b/src/backend/access/common/detoast.c index b78d49167b..95d5b1c12a 100644 --- a/src/backend/access/common/detoast.c +++ b/src/backend/access/common/detoast.c @@ -477,8 +477,8 @@ toast_get_compression_oid(struct varlena *attr) return InvalidOid; /* - * Just fetch the toast compress header to know the compression method - * in the compressed data. + * Fetch just enough of the value to examine the compression header, + * so that we can find out the compression method. */ attr = toast_fetch_datum_slice(attr, 0, VARHDRSZ_COMPRESS); } @@ -503,7 +503,6 @@ toast_get_compression_handler(struct varlena *attr) cmid = TOAST_COMPRESS_METHOD(attr); - /* Get the handler routines for the compression method */ switch (cmid) { case PGLZ_COMPRESSION_ID: diff --git a/src/backend/access/compression/compress_lz4.c b/src/backend/access/compression/compress_lz4.c index 1856cf7df7..3079eff7eb 100644 --- a/src/backend/access/compression/compress_lz4.c +++ b/src/backend/access/compression/compress_lz4.c @@ -23,7 +23,7 @@ /* * lz4_cmcompress - compression routine for lz4 compression method * - * Compresses source into dest using the default strategy. Returns the + * Compresses source into dest using the LZ4 defaults. Returns the * compressed varlena, or NULL if compression fails. */ static struct varlena * @@ -42,8 +42,8 @@ lz4_cmcompress(const struct varlena *value) valsize = VARSIZE_ANY_EXHDR(value); /* - * Get maximum size of the compressed data that lz4 compression may output - * and allocate the memory for holding the compressed data and the header. + * 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_COMPRESS); @@ -83,10 +83,10 @@ lz4_cmdecompress(const struct varlena *value) int32 rawsize; struct varlena *result; - /* allocate memory for holding the uncompressed data */ + /* allocate memory for the uncompressed data */ result = (struct varlena *) palloc(VARRAWSIZE_4B_C(value) + VARHDRSZ); - /* decompress data using lz4 routine */ + /* decompress the data */ rawsize = LZ4_decompress_safe((char *) value + VARHDRSZ_COMPRESS, VARDATA(result), VARSIZE(value) - VARHDRSZ_COMPRESS, diff --git a/src/backend/executor/nodeModifyTable.c b/src/backend/executor/nodeModifyTable.c index f77deee399..920d9dd0d5 100644 --- a/src/backend/executor/nodeModifyTable.c +++ b/src/backend/executor/nodeModifyTable.c @@ -2117,7 +2117,7 @@ CompareCompressionMethodAndDecompress(TupleTableSlot *slot, TupleTableSlot *newslot = *outslot; /* - * If the called has passed an invalid slot then create a new slot. + * If the caller has passed an invalid slot then create a new slot. * Otherwise, just clear the existing tuple from the slot. This slot * should be stored by the caller so that it can be reused for * decompressing the subsequent tuples. diff --git a/src/include/nodes/execnodes.h b/src/include/nodes/execnodes.h index 18e8ecfd90..d8483c36b3 100644 --- a/src/include/nodes/execnodes.h +++ b/src/include/nodes/execnodes.h @@ -1183,8 +1183,8 @@ typedef struct ModifyTableState TupleTableSlot *mt_root_tuple_slot; /* - * Slot for storing the modified tuple, incase the target attribute's - * compression method doesn't match with the source table. + * Slot for storing the modified tuple, in case the target attribute's + * compression method doesn't match that of the source table. */ TupleTableSlot *mt_decompress_tuple_slot; -- 2.17.0 --m51xatjYGsM+13rf Content-Type: text/x-diff; charset=us-ascii Content-Disposition: attachment; filename="v24-0006-alter-table-set-compression.patch" ^ permalink raw reply [nested|flat] 51+ messages in thread
* [PATCH v24 5/7] fixups.patch @ 2021-02-10 21:56 Robert Haas <[email protected]> 0 siblings, 0 replies; 51+ messages in thread From: Robert Haas @ 2021-02-10 21:56 UTC (permalink / raw) --- doc/src/sgml/ddl.sgml | 3 --- doc/src/sgml/ref/create_table.sgml | 15 +++++++++++---- src/backend/access/common/detoast.c | 5 ++--- src/backend/access/compression/compress_lz4.c | 10 +++++----- src/backend/executor/nodeModifyTable.c | 2 +- src/include/nodes/execnodes.h | 4 ++-- 6 files changed, 21 insertions(+), 18 deletions(-) diff --git a/doc/src/sgml/ddl.sgml b/doc/src/sgml/ddl.sgml index 4d7ed698b9..1e9a4625cc 100644 --- a/doc/src/sgml/ddl.sgml +++ b/doc/src/sgml/ddl.sgml @@ -3762,9 +3762,6 @@ CREATE TABLE measurement ( <productname>PostgreSQL</productname> tables (or, possibly, foreign tables). It is possible to specify a tablespace and storage parameters for each partition separately. - By default, each column in a partition inherits the compression method - from parent table's column, however a different compression method can be - set for each partition. </para> <para> diff --git a/doc/src/sgml/ref/create_table.sgml b/doc/src/sgml/ref/create_table.sgml index 51a7a977a5..a4b297340f 100644 --- a/doc/src/sgml/ref/create_table.sgml +++ b/doc/src/sgml/ref/create_table.sgml @@ -997,10 +997,17 @@ WITH ( MODULUS <replaceable class="parameter">numeric_literal</replaceable>, REM <term><literal>COMPRESSION <replaceable class="parameter">compression_method</replaceable></literal></term> <listitem> <para> - This sets the compression method for a column. The supported compression - methods are <literal>pglz</literal> and <literal>lz4</literal>. - <literal>lz4</literal> is available only if <literal>--with-lz4</literal> - was used when building <productname>PostgreSQL</productname>. The default + The <literal>COMPRESSION</literal> clause sets the compression method + for a column. Compression is supported only for variable-width data + types, and is used only for columns whose storage type is main or + extended. (See <xref linkend="sql-altertable"/> for information on + column storage types.) Setting this property for a partitioned table + has no direct effect, because such tables have no storage of their own, + but the configured value is inherited by newly-created partitions. + The supported compression methods are <literal>pglz</literal> and + <literal>lz4</literal>. <literal>lz4</literal> is available only if + <literal>--with-lz4</literal> was used when building + <productname>PostgreSQL</productname>. The default is <literal>pglz</literal>. </para> </listitem> diff --git a/src/backend/access/common/detoast.c b/src/backend/access/common/detoast.c index b78d49167b..95d5b1c12a 100644 --- a/src/backend/access/common/detoast.c +++ b/src/backend/access/common/detoast.c @@ -477,8 +477,8 @@ toast_get_compression_oid(struct varlena *attr) return InvalidOid; /* - * Just fetch the toast compress header to know the compression method - * in the compressed data. + * Fetch just enough of the value to examine the compression header, + * so that we can find out the compression method. */ attr = toast_fetch_datum_slice(attr, 0, VARHDRSZ_COMPRESS); } @@ -503,7 +503,6 @@ toast_get_compression_handler(struct varlena *attr) cmid = TOAST_COMPRESS_METHOD(attr); - /* Get the handler routines for the compression method */ switch (cmid) { case PGLZ_COMPRESSION_ID: diff --git a/src/backend/access/compression/compress_lz4.c b/src/backend/access/compression/compress_lz4.c index 1856cf7df7..3079eff7eb 100644 --- a/src/backend/access/compression/compress_lz4.c +++ b/src/backend/access/compression/compress_lz4.c @@ -23,7 +23,7 @@ /* * lz4_cmcompress - compression routine for lz4 compression method * - * Compresses source into dest using the default strategy. Returns the + * Compresses source into dest using the LZ4 defaults. Returns the * compressed varlena, or NULL if compression fails. */ static struct varlena * @@ -42,8 +42,8 @@ lz4_cmcompress(const struct varlena *value) valsize = VARSIZE_ANY_EXHDR(value); /* - * Get maximum size of the compressed data that lz4 compression may output - * and allocate the memory for holding the compressed data and the header. + * 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_COMPRESS); @@ -83,10 +83,10 @@ lz4_cmdecompress(const struct varlena *value) int32 rawsize; struct varlena *result; - /* allocate memory for holding the uncompressed data */ + /* allocate memory for the uncompressed data */ result = (struct varlena *) palloc(VARRAWSIZE_4B_C(value) + VARHDRSZ); - /* decompress data using lz4 routine */ + /* decompress the data */ rawsize = LZ4_decompress_safe((char *) value + VARHDRSZ_COMPRESS, VARDATA(result), VARSIZE(value) - VARHDRSZ_COMPRESS, diff --git a/src/backend/executor/nodeModifyTable.c b/src/backend/executor/nodeModifyTable.c index f77deee399..920d9dd0d5 100644 --- a/src/backend/executor/nodeModifyTable.c +++ b/src/backend/executor/nodeModifyTable.c @@ -2117,7 +2117,7 @@ CompareCompressionMethodAndDecompress(TupleTableSlot *slot, TupleTableSlot *newslot = *outslot; /* - * If the called has passed an invalid slot then create a new slot. + * If the caller has passed an invalid slot then create a new slot. * Otherwise, just clear the existing tuple from the slot. This slot * should be stored by the caller so that it can be reused for * decompressing the subsequent tuples. diff --git a/src/include/nodes/execnodes.h b/src/include/nodes/execnodes.h index 18e8ecfd90..d8483c36b3 100644 --- a/src/include/nodes/execnodes.h +++ b/src/include/nodes/execnodes.h @@ -1183,8 +1183,8 @@ typedef struct ModifyTableState TupleTableSlot *mt_root_tuple_slot; /* - * Slot for storing the modified tuple, incase the target attribute's - * compression method doesn't match with the source table. + * Slot for storing the modified tuple, in case the target attribute's + * compression method doesn't match that of the source table. */ TupleTableSlot *mt_decompress_tuple_slot; -- 2.17.0 --YZ5djTAD1cGYuMQK Content-Type: text/x-diff; charset=us-ascii Content-Disposition: attachment; filename="v24-0006-alter-table-set-compression.patch" ^ permalink raw reply [nested|flat] 51+ messages in thread
* [PATCH v24 05/10] fixups.patch @ 2021-02-10 21:56 Robert Haas <[email protected]> 0 siblings, 0 replies; 51+ messages in thread From: Robert Haas @ 2021-02-10 21:56 UTC (permalink / raw) --- doc/src/sgml/ddl.sgml | 3 --- doc/src/sgml/ref/create_table.sgml | 15 +++++++++++---- src/backend/access/common/detoast.c | 5 ++--- src/backend/access/compression/compress_lz4.c | 10 +++++----- src/backend/executor/nodeModifyTable.c | 2 +- src/include/nodes/execnodes.h | 4 ++-- 6 files changed, 21 insertions(+), 18 deletions(-) diff --git a/doc/src/sgml/ddl.sgml b/doc/src/sgml/ddl.sgml index 4d7ed698b9..1e9a4625cc 100644 --- a/doc/src/sgml/ddl.sgml +++ b/doc/src/sgml/ddl.sgml @@ -3762,9 +3762,6 @@ CREATE TABLE measurement ( <productname>PostgreSQL</productname> tables (or, possibly, foreign tables). It is possible to specify a tablespace and storage parameters for each partition separately. - By default, each column in a partition inherits the compression method - from parent table's column, however a different compression method can be - set for each partition. </para> <para> diff --git a/doc/src/sgml/ref/create_table.sgml b/doc/src/sgml/ref/create_table.sgml index 51a7a977a5..a4b297340f 100644 --- a/doc/src/sgml/ref/create_table.sgml +++ b/doc/src/sgml/ref/create_table.sgml @@ -997,10 +997,17 @@ WITH ( MODULUS <replaceable class="parameter">numeric_literal</replaceable>, REM <term><literal>COMPRESSION <replaceable class="parameter">compression_method</replaceable></literal></term> <listitem> <para> - This sets the compression method for a column. The supported compression - methods are <literal>pglz</literal> and <literal>lz4</literal>. - <literal>lz4</literal> is available only if <literal>--with-lz4</literal> - was used when building <productname>PostgreSQL</productname>. The default + The <literal>COMPRESSION</literal> clause sets the compression method + for a column. Compression is supported only for variable-width data + types, and is used only for columns whose storage type is main or + extended. (See <xref linkend="sql-altertable"/> for information on + column storage types.) Setting this property for a partitioned table + has no direct effect, because such tables have no storage of their own, + but the configured value is inherited by newly-created partitions. + The supported compression methods are <literal>pglz</literal> and + <literal>lz4</literal>. <literal>lz4</literal> is available only if + <literal>--with-lz4</literal> was used when building + <productname>PostgreSQL</productname>. The default is <literal>pglz</literal>. </para> </listitem> diff --git a/src/backend/access/common/detoast.c b/src/backend/access/common/detoast.c index b78d49167b..95d5b1c12a 100644 --- a/src/backend/access/common/detoast.c +++ b/src/backend/access/common/detoast.c @@ -477,8 +477,8 @@ toast_get_compression_oid(struct varlena *attr) return InvalidOid; /* - * Just fetch the toast compress header to know the compression method - * in the compressed data. + * Fetch just enough of the value to examine the compression header, + * so that we can find out the compression method. */ attr = toast_fetch_datum_slice(attr, 0, VARHDRSZ_COMPRESS); } @@ -503,7 +503,6 @@ toast_get_compression_handler(struct varlena *attr) cmid = TOAST_COMPRESS_METHOD(attr); - /* Get the handler routines for the compression method */ switch (cmid) { case PGLZ_COMPRESSION_ID: diff --git a/src/backend/access/compression/compress_lz4.c b/src/backend/access/compression/compress_lz4.c index 1856cf7df7..3079eff7eb 100644 --- a/src/backend/access/compression/compress_lz4.c +++ b/src/backend/access/compression/compress_lz4.c @@ -23,7 +23,7 @@ /* * lz4_cmcompress - compression routine for lz4 compression method * - * Compresses source into dest using the default strategy. Returns the + * Compresses source into dest using the LZ4 defaults. Returns the * compressed varlena, or NULL if compression fails. */ static struct varlena * @@ -42,8 +42,8 @@ lz4_cmcompress(const struct varlena *value) valsize = VARSIZE_ANY_EXHDR(value); /* - * Get maximum size of the compressed data that lz4 compression may output - * and allocate the memory for holding the compressed data and the header. + * 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_COMPRESS); @@ -83,10 +83,10 @@ lz4_cmdecompress(const struct varlena *value) int32 rawsize; struct varlena *result; - /* allocate memory for holding the uncompressed data */ + /* allocate memory for the uncompressed data */ result = (struct varlena *) palloc(VARRAWSIZE_4B_C(value) + VARHDRSZ); - /* decompress data using lz4 routine */ + /* decompress the data */ rawsize = LZ4_decompress_safe((char *) value + VARHDRSZ_COMPRESS, VARDATA(result), VARSIZE(value) - VARHDRSZ_COMPRESS, diff --git a/src/backend/executor/nodeModifyTable.c b/src/backend/executor/nodeModifyTable.c index f77deee399..920d9dd0d5 100644 --- a/src/backend/executor/nodeModifyTable.c +++ b/src/backend/executor/nodeModifyTable.c @@ -2117,7 +2117,7 @@ CompareCompressionMethodAndDecompress(TupleTableSlot *slot, TupleTableSlot *newslot = *outslot; /* - * If the called has passed an invalid slot then create a new slot. + * If the caller has passed an invalid slot then create a new slot. * Otherwise, just clear the existing tuple from the slot. This slot * should be stored by the caller so that it can be reused for * decompressing the subsequent tuples. diff --git a/src/include/nodes/execnodes.h b/src/include/nodes/execnodes.h index 18e8ecfd90..d8483c36b3 100644 --- a/src/include/nodes/execnodes.h +++ b/src/include/nodes/execnodes.h @@ -1183,8 +1183,8 @@ typedef struct ModifyTableState TupleTableSlot *mt_root_tuple_slot; /* - * Slot for storing the modified tuple, incase the target attribute's - * compression method doesn't match with the source table. + * Slot for storing the modified tuple, in case the target attribute's + * compression method doesn't match that of the source table. */ TupleTableSlot *mt_decompress_tuple_slot; -- 2.17.0 --m51xatjYGsM+13rf Content-Type: text/x-diff; charset=us-ascii Content-Disposition: attachment; filename="v24-0006-alter-table-set-compression.patch" ^ permalink raw reply [nested|flat] 51+ messages in thread
* [PATCH v24 5/7] fixups.patch @ 2021-02-10 21:56 Robert Haas <[email protected]> 0 siblings, 0 replies; 51+ messages in thread From: Robert Haas @ 2021-02-10 21:56 UTC (permalink / raw) --- doc/src/sgml/ddl.sgml | 3 --- doc/src/sgml/ref/create_table.sgml | 15 +++++++++++---- src/backend/access/common/detoast.c | 5 ++--- src/backend/access/compression/compress_lz4.c | 10 +++++----- src/backend/executor/nodeModifyTable.c | 2 +- src/include/nodes/execnodes.h | 4 ++-- 6 files changed, 21 insertions(+), 18 deletions(-) diff --git a/doc/src/sgml/ddl.sgml b/doc/src/sgml/ddl.sgml index 4d7ed698b9..1e9a4625cc 100644 --- a/doc/src/sgml/ddl.sgml +++ b/doc/src/sgml/ddl.sgml @@ -3762,9 +3762,6 @@ CREATE TABLE measurement ( <productname>PostgreSQL</productname> tables (or, possibly, foreign tables). It is possible to specify a tablespace and storage parameters for each partition separately. - By default, each column in a partition inherits the compression method - from parent table's column, however a different compression method can be - set for each partition. </para> <para> diff --git a/doc/src/sgml/ref/create_table.sgml b/doc/src/sgml/ref/create_table.sgml index 51a7a977a5..a4b297340f 100644 --- a/doc/src/sgml/ref/create_table.sgml +++ b/doc/src/sgml/ref/create_table.sgml @@ -997,10 +997,17 @@ WITH ( MODULUS <replaceable class="parameter">numeric_literal</replaceable>, REM <term><literal>COMPRESSION <replaceable class="parameter">compression_method</replaceable></literal></term> <listitem> <para> - This sets the compression method for a column. The supported compression - methods are <literal>pglz</literal> and <literal>lz4</literal>. - <literal>lz4</literal> is available only if <literal>--with-lz4</literal> - was used when building <productname>PostgreSQL</productname>. The default + The <literal>COMPRESSION</literal> clause sets the compression method + for a column. Compression is supported only for variable-width data + types, and is used only for columns whose storage type is main or + extended. (See <xref linkend="sql-altertable"/> for information on + column storage types.) Setting this property for a partitioned table + has no direct effect, because such tables have no storage of their own, + but the configured value is inherited by newly-created partitions. + The supported compression methods are <literal>pglz</literal> and + <literal>lz4</literal>. <literal>lz4</literal> is available only if + <literal>--with-lz4</literal> was used when building + <productname>PostgreSQL</productname>. The default is <literal>pglz</literal>. </para> </listitem> diff --git a/src/backend/access/common/detoast.c b/src/backend/access/common/detoast.c index b78d49167b..95d5b1c12a 100644 --- a/src/backend/access/common/detoast.c +++ b/src/backend/access/common/detoast.c @@ -477,8 +477,8 @@ toast_get_compression_oid(struct varlena *attr) return InvalidOid; /* - * Just fetch the toast compress header to know the compression method - * in the compressed data. + * Fetch just enough of the value to examine the compression header, + * so that we can find out the compression method. */ attr = toast_fetch_datum_slice(attr, 0, VARHDRSZ_COMPRESS); } @@ -503,7 +503,6 @@ toast_get_compression_handler(struct varlena *attr) cmid = TOAST_COMPRESS_METHOD(attr); - /* Get the handler routines for the compression method */ switch (cmid) { case PGLZ_COMPRESSION_ID: diff --git a/src/backend/access/compression/compress_lz4.c b/src/backend/access/compression/compress_lz4.c index 1856cf7df7..3079eff7eb 100644 --- a/src/backend/access/compression/compress_lz4.c +++ b/src/backend/access/compression/compress_lz4.c @@ -23,7 +23,7 @@ /* * lz4_cmcompress - compression routine for lz4 compression method * - * Compresses source into dest using the default strategy. Returns the + * Compresses source into dest using the LZ4 defaults. Returns the * compressed varlena, or NULL if compression fails. */ static struct varlena * @@ -42,8 +42,8 @@ lz4_cmcompress(const struct varlena *value) valsize = VARSIZE_ANY_EXHDR(value); /* - * Get maximum size of the compressed data that lz4 compression may output - * and allocate the memory for holding the compressed data and the header. + * 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_COMPRESS); @@ -83,10 +83,10 @@ lz4_cmdecompress(const struct varlena *value) int32 rawsize; struct varlena *result; - /* allocate memory for holding the uncompressed data */ + /* allocate memory for the uncompressed data */ result = (struct varlena *) palloc(VARRAWSIZE_4B_C(value) + VARHDRSZ); - /* decompress data using lz4 routine */ + /* decompress the data */ rawsize = LZ4_decompress_safe((char *) value + VARHDRSZ_COMPRESS, VARDATA(result), VARSIZE(value) - VARHDRSZ_COMPRESS, diff --git a/src/backend/executor/nodeModifyTable.c b/src/backend/executor/nodeModifyTable.c index f77deee399..920d9dd0d5 100644 --- a/src/backend/executor/nodeModifyTable.c +++ b/src/backend/executor/nodeModifyTable.c @@ -2117,7 +2117,7 @@ CompareCompressionMethodAndDecompress(TupleTableSlot *slot, TupleTableSlot *newslot = *outslot; /* - * If the called has passed an invalid slot then create a new slot. + * If the caller has passed an invalid slot then create a new slot. * Otherwise, just clear the existing tuple from the slot. This slot * should be stored by the caller so that it can be reused for * decompressing the subsequent tuples. diff --git a/src/include/nodes/execnodes.h b/src/include/nodes/execnodes.h index 18e8ecfd90..d8483c36b3 100644 --- a/src/include/nodes/execnodes.h +++ b/src/include/nodes/execnodes.h @@ -1183,8 +1183,8 @@ typedef struct ModifyTableState TupleTableSlot *mt_root_tuple_slot; /* - * Slot for storing the modified tuple, incase the target attribute's - * compression method doesn't match with the source table. + * Slot for storing the modified tuple, in case the target attribute's + * compression method doesn't match that of the source table. */ TupleTableSlot *mt_decompress_tuple_slot; -- 2.17.0 --YZ5djTAD1cGYuMQK Content-Type: text/x-diff; charset=us-ascii Content-Disposition: attachment; filename="v24-0006-alter-table-set-compression.patch" ^ permalink raw reply [nested|flat] 51+ messages in thread
* [PATCH v24 05/10] fixups.patch @ 2021-02-10 21:56 Robert Haas <[email protected]> 0 siblings, 0 replies; 51+ messages in thread From: Robert Haas @ 2021-02-10 21:56 UTC (permalink / raw) --- doc/src/sgml/ddl.sgml | 3 --- doc/src/sgml/ref/create_table.sgml | 15 +++++++++++---- src/backend/access/common/detoast.c | 5 ++--- src/backend/access/compression/compress_lz4.c | 10 +++++----- src/backend/executor/nodeModifyTable.c | 2 +- src/include/nodes/execnodes.h | 4 ++-- 6 files changed, 21 insertions(+), 18 deletions(-) diff --git a/doc/src/sgml/ddl.sgml b/doc/src/sgml/ddl.sgml index 4d7ed698b9..1e9a4625cc 100644 --- a/doc/src/sgml/ddl.sgml +++ b/doc/src/sgml/ddl.sgml @@ -3762,9 +3762,6 @@ CREATE TABLE measurement ( <productname>PostgreSQL</productname> tables (or, possibly, foreign tables). It is possible to specify a tablespace and storage parameters for each partition separately. - By default, each column in a partition inherits the compression method - from parent table's column, however a different compression method can be - set for each partition. </para> <para> diff --git a/doc/src/sgml/ref/create_table.sgml b/doc/src/sgml/ref/create_table.sgml index 51a7a977a5..a4b297340f 100644 --- a/doc/src/sgml/ref/create_table.sgml +++ b/doc/src/sgml/ref/create_table.sgml @@ -997,10 +997,17 @@ WITH ( MODULUS <replaceable class="parameter">numeric_literal</replaceable>, REM <term><literal>COMPRESSION <replaceable class="parameter">compression_method</replaceable></literal></term> <listitem> <para> - This sets the compression method for a column. The supported compression - methods are <literal>pglz</literal> and <literal>lz4</literal>. - <literal>lz4</literal> is available only if <literal>--with-lz4</literal> - was used when building <productname>PostgreSQL</productname>. The default + The <literal>COMPRESSION</literal> clause sets the compression method + for a column. Compression is supported only for variable-width data + types, and is used only for columns whose storage type is main or + extended. (See <xref linkend="sql-altertable"/> for information on + column storage types.) Setting this property for a partitioned table + has no direct effect, because such tables have no storage of their own, + but the configured value is inherited by newly-created partitions. + The supported compression methods are <literal>pglz</literal> and + <literal>lz4</literal>. <literal>lz4</literal> is available only if + <literal>--with-lz4</literal> was used when building + <productname>PostgreSQL</productname>. The default is <literal>pglz</literal>. </para> </listitem> diff --git a/src/backend/access/common/detoast.c b/src/backend/access/common/detoast.c index b78d49167b..95d5b1c12a 100644 --- a/src/backend/access/common/detoast.c +++ b/src/backend/access/common/detoast.c @@ -477,8 +477,8 @@ toast_get_compression_oid(struct varlena *attr) return InvalidOid; /* - * Just fetch the toast compress header to know the compression method - * in the compressed data. + * Fetch just enough of the value to examine the compression header, + * so that we can find out the compression method. */ attr = toast_fetch_datum_slice(attr, 0, VARHDRSZ_COMPRESS); } @@ -503,7 +503,6 @@ toast_get_compression_handler(struct varlena *attr) cmid = TOAST_COMPRESS_METHOD(attr); - /* Get the handler routines for the compression method */ switch (cmid) { case PGLZ_COMPRESSION_ID: diff --git a/src/backend/access/compression/compress_lz4.c b/src/backend/access/compression/compress_lz4.c index 1856cf7df7..3079eff7eb 100644 --- a/src/backend/access/compression/compress_lz4.c +++ b/src/backend/access/compression/compress_lz4.c @@ -23,7 +23,7 @@ /* * lz4_cmcompress - compression routine for lz4 compression method * - * Compresses source into dest using the default strategy. Returns the + * Compresses source into dest using the LZ4 defaults. Returns the * compressed varlena, or NULL if compression fails. */ static struct varlena * @@ -42,8 +42,8 @@ lz4_cmcompress(const struct varlena *value) valsize = VARSIZE_ANY_EXHDR(value); /* - * Get maximum size of the compressed data that lz4 compression may output - * and allocate the memory for holding the compressed data and the header. + * 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_COMPRESS); @@ -83,10 +83,10 @@ lz4_cmdecompress(const struct varlena *value) int32 rawsize; struct varlena *result; - /* allocate memory for holding the uncompressed data */ + /* allocate memory for the uncompressed data */ result = (struct varlena *) palloc(VARRAWSIZE_4B_C(value) + VARHDRSZ); - /* decompress data using lz4 routine */ + /* decompress the data */ rawsize = LZ4_decompress_safe((char *) value + VARHDRSZ_COMPRESS, VARDATA(result), VARSIZE(value) - VARHDRSZ_COMPRESS, diff --git a/src/backend/executor/nodeModifyTable.c b/src/backend/executor/nodeModifyTable.c index f77deee399..920d9dd0d5 100644 --- a/src/backend/executor/nodeModifyTable.c +++ b/src/backend/executor/nodeModifyTable.c @@ -2117,7 +2117,7 @@ CompareCompressionMethodAndDecompress(TupleTableSlot *slot, TupleTableSlot *newslot = *outslot; /* - * If the called has passed an invalid slot then create a new slot. + * If the caller has passed an invalid slot then create a new slot. * Otherwise, just clear the existing tuple from the slot. This slot * should be stored by the caller so that it can be reused for * decompressing the subsequent tuples. diff --git a/src/include/nodes/execnodes.h b/src/include/nodes/execnodes.h index 18e8ecfd90..d8483c36b3 100644 --- a/src/include/nodes/execnodes.h +++ b/src/include/nodes/execnodes.h @@ -1183,8 +1183,8 @@ typedef struct ModifyTableState TupleTableSlot *mt_root_tuple_slot; /* - * Slot for storing the modified tuple, incase the target attribute's - * compression method doesn't match with the source table. + * Slot for storing the modified tuple, in case the target attribute's + * compression method doesn't match that of the source table. */ TupleTableSlot *mt_decompress_tuple_slot; -- 2.17.0 --m51xatjYGsM+13rf Content-Type: text/x-diff; charset=us-ascii Content-Disposition: attachment; filename="v24-0006-alter-table-set-compression.patch" ^ permalink raw reply [nested|flat] 51+ messages in thread
* [PATCH v24 5/7] fixups.patch @ 2021-02-10 21:56 Robert Haas <[email protected]> 0 siblings, 0 replies; 51+ messages in thread From: Robert Haas @ 2021-02-10 21:56 UTC (permalink / raw) --- doc/src/sgml/ddl.sgml | 3 --- doc/src/sgml/ref/create_table.sgml | 15 +++++++++++---- src/backend/access/common/detoast.c | 5 ++--- src/backend/access/compression/compress_lz4.c | 10 +++++----- src/backend/executor/nodeModifyTable.c | 2 +- src/include/nodes/execnodes.h | 4 ++-- 6 files changed, 21 insertions(+), 18 deletions(-) diff --git a/doc/src/sgml/ddl.sgml b/doc/src/sgml/ddl.sgml index 4d7ed698b9..1e9a4625cc 100644 --- a/doc/src/sgml/ddl.sgml +++ b/doc/src/sgml/ddl.sgml @@ -3762,9 +3762,6 @@ CREATE TABLE measurement ( <productname>PostgreSQL</productname> tables (or, possibly, foreign tables). It is possible to specify a tablespace and storage parameters for each partition separately. - By default, each column in a partition inherits the compression method - from parent table's column, however a different compression method can be - set for each partition. </para> <para> diff --git a/doc/src/sgml/ref/create_table.sgml b/doc/src/sgml/ref/create_table.sgml index 51a7a977a5..a4b297340f 100644 --- a/doc/src/sgml/ref/create_table.sgml +++ b/doc/src/sgml/ref/create_table.sgml @@ -997,10 +997,17 @@ WITH ( MODULUS <replaceable class="parameter">numeric_literal</replaceable>, REM <term><literal>COMPRESSION <replaceable class="parameter">compression_method</replaceable></literal></term> <listitem> <para> - This sets the compression method for a column. The supported compression - methods are <literal>pglz</literal> and <literal>lz4</literal>. - <literal>lz4</literal> is available only if <literal>--with-lz4</literal> - was used when building <productname>PostgreSQL</productname>. The default + The <literal>COMPRESSION</literal> clause sets the compression method + for a column. Compression is supported only for variable-width data + types, and is used only for columns whose storage type is main or + extended. (See <xref linkend="sql-altertable"/> for information on + column storage types.) Setting this property for a partitioned table + has no direct effect, because such tables have no storage of their own, + but the configured value is inherited by newly-created partitions. + The supported compression methods are <literal>pglz</literal> and + <literal>lz4</literal>. <literal>lz4</literal> is available only if + <literal>--with-lz4</literal> was used when building + <productname>PostgreSQL</productname>. The default is <literal>pglz</literal>. </para> </listitem> diff --git a/src/backend/access/common/detoast.c b/src/backend/access/common/detoast.c index b78d49167b..95d5b1c12a 100644 --- a/src/backend/access/common/detoast.c +++ b/src/backend/access/common/detoast.c @@ -477,8 +477,8 @@ toast_get_compression_oid(struct varlena *attr) return InvalidOid; /* - * Just fetch the toast compress header to know the compression method - * in the compressed data. + * Fetch just enough of the value to examine the compression header, + * so that we can find out the compression method. */ attr = toast_fetch_datum_slice(attr, 0, VARHDRSZ_COMPRESS); } @@ -503,7 +503,6 @@ toast_get_compression_handler(struct varlena *attr) cmid = TOAST_COMPRESS_METHOD(attr); - /* Get the handler routines for the compression method */ switch (cmid) { case PGLZ_COMPRESSION_ID: diff --git a/src/backend/access/compression/compress_lz4.c b/src/backend/access/compression/compress_lz4.c index 1856cf7df7..3079eff7eb 100644 --- a/src/backend/access/compression/compress_lz4.c +++ b/src/backend/access/compression/compress_lz4.c @@ -23,7 +23,7 @@ /* * lz4_cmcompress - compression routine for lz4 compression method * - * Compresses source into dest using the default strategy. Returns the + * Compresses source into dest using the LZ4 defaults. Returns the * compressed varlena, or NULL if compression fails. */ static struct varlena * @@ -42,8 +42,8 @@ lz4_cmcompress(const struct varlena *value) valsize = VARSIZE_ANY_EXHDR(value); /* - * Get maximum size of the compressed data that lz4 compression may output - * and allocate the memory for holding the compressed data and the header. + * 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_COMPRESS); @@ -83,10 +83,10 @@ lz4_cmdecompress(const struct varlena *value) int32 rawsize; struct varlena *result; - /* allocate memory for holding the uncompressed data */ + /* allocate memory for the uncompressed data */ result = (struct varlena *) palloc(VARRAWSIZE_4B_C(value) + VARHDRSZ); - /* decompress data using lz4 routine */ + /* decompress the data */ rawsize = LZ4_decompress_safe((char *) value + VARHDRSZ_COMPRESS, VARDATA(result), VARSIZE(value) - VARHDRSZ_COMPRESS, diff --git a/src/backend/executor/nodeModifyTable.c b/src/backend/executor/nodeModifyTable.c index f77deee399..920d9dd0d5 100644 --- a/src/backend/executor/nodeModifyTable.c +++ b/src/backend/executor/nodeModifyTable.c @@ -2117,7 +2117,7 @@ CompareCompressionMethodAndDecompress(TupleTableSlot *slot, TupleTableSlot *newslot = *outslot; /* - * If the called has passed an invalid slot then create a new slot. + * If the caller has passed an invalid slot then create a new slot. * Otherwise, just clear the existing tuple from the slot. This slot * should be stored by the caller so that it can be reused for * decompressing the subsequent tuples. diff --git a/src/include/nodes/execnodes.h b/src/include/nodes/execnodes.h index 18e8ecfd90..d8483c36b3 100644 --- a/src/include/nodes/execnodes.h +++ b/src/include/nodes/execnodes.h @@ -1183,8 +1183,8 @@ typedef struct ModifyTableState TupleTableSlot *mt_root_tuple_slot; /* - * Slot for storing the modified tuple, incase the target attribute's - * compression method doesn't match with the source table. + * Slot for storing the modified tuple, in case the target attribute's + * compression method doesn't match that of the source table. */ TupleTableSlot *mt_decompress_tuple_slot; -- 2.17.0 --YZ5djTAD1cGYuMQK Content-Type: text/x-diff; charset=us-ascii Content-Disposition: attachment; filename="v24-0006-alter-table-set-compression.patch" ^ permalink raw reply [nested|flat] 51+ messages in thread
* [PATCH v24 05/10] fixups.patch @ 2021-02-10 21:56 Robert Haas <[email protected]> 0 siblings, 0 replies; 51+ messages in thread From: Robert Haas @ 2021-02-10 21:56 UTC (permalink / raw) --- doc/src/sgml/ddl.sgml | 3 --- doc/src/sgml/ref/create_table.sgml | 15 +++++++++++---- src/backend/access/common/detoast.c | 5 ++--- src/backend/access/compression/compress_lz4.c | 10 +++++----- src/backend/executor/nodeModifyTable.c | 2 +- src/include/nodes/execnodes.h | 4 ++-- 6 files changed, 21 insertions(+), 18 deletions(-) diff --git a/doc/src/sgml/ddl.sgml b/doc/src/sgml/ddl.sgml index 4d7ed698b9..1e9a4625cc 100644 --- a/doc/src/sgml/ddl.sgml +++ b/doc/src/sgml/ddl.sgml @@ -3762,9 +3762,6 @@ CREATE TABLE measurement ( <productname>PostgreSQL</productname> tables (or, possibly, foreign tables). It is possible to specify a tablespace and storage parameters for each partition separately. - By default, each column in a partition inherits the compression method - from parent table's column, however a different compression method can be - set for each partition. </para> <para> diff --git a/doc/src/sgml/ref/create_table.sgml b/doc/src/sgml/ref/create_table.sgml index 51a7a977a5..a4b297340f 100644 --- a/doc/src/sgml/ref/create_table.sgml +++ b/doc/src/sgml/ref/create_table.sgml @@ -997,10 +997,17 @@ WITH ( MODULUS <replaceable class="parameter">numeric_literal</replaceable>, REM <term><literal>COMPRESSION <replaceable class="parameter">compression_method</replaceable></literal></term> <listitem> <para> - This sets the compression method for a column. The supported compression - methods are <literal>pglz</literal> and <literal>lz4</literal>. - <literal>lz4</literal> is available only if <literal>--with-lz4</literal> - was used when building <productname>PostgreSQL</productname>. The default + The <literal>COMPRESSION</literal> clause sets the compression method + for a column. Compression is supported only for variable-width data + types, and is used only for columns whose storage type is main or + extended. (See <xref linkend="sql-altertable"/> for information on + column storage types.) Setting this property for a partitioned table + has no direct effect, because such tables have no storage of their own, + but the configured value is inherited by newly-created partitions. + The supported compression methods are <literal>pglz</literal> and + <literal>lz4</literal>. <literal>lz4</literal> is available only if + <literal>--with-lz4</literal> was used when building + <productname>PostgreSQL</productname>. The default is <literal>pglz</literal>. </para> </listitem> diff --git a/src/backend/access/common/detoast.c b/src/backend/access/common/detoast.c index b78d49167b..95d5b1c12a 100644 --- a/src/backend/access/common/detoast.c +++ b/src/backend/access/common/detoast.c @@ -477,8 +477,8 @@ toast_get_compression_oid(struct varlena *attr) return InvalidOid; /* - * Just fetch the toast compress header to know the compression method - * in the compressed data. + * Fetch just enough of the value to examine the compression header, + * so that we can find out the compression method. */ attr = toast_fetch_datum_slice(attr, 0, VARHDRSZ_COMPRESS); } @@ -503,7 +503,6 @@ toast_get_compression_handler(struct varlena *attr) cmid = TOAST_COMPRESS_METHOD(attr); - /* Get the handler routines for the compression method */ switch (cmid) { case PGLZ_COMPRESSION_ID: diff --git a/src/backend/access/compression/compress_lz4.c b/src/backend/access/compression/compress_lz4.c index 1856cf7df7..3079eff7eb 100644 --- a/src/backend/access/compression/compress_lz4.c +++ b/src/backend/access/compression/compress_lz4.c @@ -23,7 +23,7 @@ /* * lz4_cmcompress - compression routine for lz4 compression method * - * Compresses source into dest using the default strategy. Returns the + * Compresses source into dest using the LZ4 defaults. Returns the * compressed varlena, or NULL if compression fails. */ static struct varlena * @@ -42,8 +42,8 @@ lz4_cmcompress(const struct varlena *value) valsize = VARSIZE_ANY_EXHDR(value); /* - * Get maximum size of the compressed data that lz4 compression may output - * and allocate the memory for holding the compressed data and the header. + * 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_COMPRESS); @@ -83,10 +83,10 @@ lz4_cmdecompress(const struct varlena *value) int32 rawsize; struct varlena *result; - /* allocate memory for holding the uncompressed data */ + /* allocate memory for the uncompressed data */ result = (struct varlena *) palloc(VARRAWSIZE_4B_C(value) + VARHDRSZ); - /* decompress data using lz4 routine */ + /* decompress the data */ rawsize = LZ4_decompress_safe((char *) value + VARHDRSZ_COMPRESS, VARDATA(result), VARSIZE(value) - VARHDRSZ_COMPRESS, diff --git a/src/backend/executor/nodeModifyTable.c b/src/backend/executor/nodeModifyTable.c index f77deee399..920d9dd0d5 100644 --- a/src/backend/executor/nodeModifyTable.c +++ b/src/backend/executor/nodeModifyTable.c @@ -2117,7 +2117,7 @@ CompareCompressionMethodAndDecompress(TupleTableSlot *slot, TupleTableSlot *newslot = *outslot; /* - * If the called has passed an invalid slot then create a new slot. + * If the caller has passed an invalid slot then create a new slot. * Otherwise, just clear the existing tuple from the slot. This slot * should be stored by the caller so that it can be reused for * decompressing the subsequent tuples. diff --git a/src/include/nodes/execnodes.h b/src/include/nodes/execnodes.h index 18e8ecfd90..d8483c36b3 100644 --- a/src/include/nodes/execnodes.h +++ b/src/include/nodes/execnodes.h @@ -1183,8 +1183,8 @@ typedef struct ModifyTableState TupleTableSlot *mt_root_tuple_slot; /* - * Slot for storing the modified tuple, incase the target attribute's - * compression method doesn't match with the source table. + * Slot for storing the modified tuple, in case the target attribute's + * compression method doesn't match that of the source table. */ TupleTableSlot *mt_decompress_tuple_slot; -- 2.17.0 --m51xatjYGsM+13rf Content-Type: text/x-diff; charset=us-ascii Content-Disposition: attachment; filename="v24-0006-alter-table-set-compression.patch" ^ permalink raw reply [nested|flat] 51+ messages in thread
* [PATCH v24 5/7] fixups.patch @ 2021-02-10 21:56 Robert Haas <[email protected]> 0 siblings, 0 replies; 51+ messages in thread From: Robert Haas @ 2021-02-10 21:56 UTC (permalink / raw) --- doc/src/sgml/ddl.sgml | 3 --- doc/src/sgml/ref/create_table.sgml | 15 +++++++++++---- src/backend/access/common/detoast.c | 5 ++--- src/backend/access/compression/compress_lz4.c | 10 +++++----- src/backend/executor/nodeModifyTable.c | 2 +- src/include/nodes/execnodes.h | 4 ++-- 6 files changed, 21 insertions(+), 18 deletions(-) diff --git a/doc/src/sgml/ddl.sgml b/doc/src/sgml/ddl.sgml index 4d7ed698b9..1e9a4625cc 100644 --- a/doc/src/sgml/ddl.sgml +++ b/doc/src/sgml/ddl.sgml @@ -3762,9 +3762,6 @@ CREATE TABLE measurement ( <productname>PostgreSQL</productname> tables (or, possibly, foreign tables). It is possible to specify a tablespace and storage parameters for each partition separately. - By default, each column in a partition inherits the compression method - from parent table's column, however a different compression method can be - set for each partition. </para> <para> diff --git a/doc/src/sgml/ref/create_table.sgml b/doc/src/sgml/ref/create_table.sgml index 51a7a977a5..a4b297340f 100644 --- a/doc/src/sgml/ref/create_table.sgml +++ b/doc/src/sgml/ref/create_table.sgml @@ -997,10 +997,17 @@ WITH ( MODULUS <replaceable class="parameter">numeric_literal</replaceable>, REM <term><literal>COMPRESSION <replaceable class="parameter">compression_method</replaceable></literal></term> <listitem> <para> - This sets the compression method for a column. The supported compression - methods are <literal>pglz</literal> and <literal>lz4</literal>. - <literal>lz4</literal> is available only if <literal>--with-lz4</literal> - was used when building <productname>PostgreSQL</productname>. The default + The <literal>COMPRESSION</literal> clause sets the compression method + for a column. Compression is supported only for variable-width data + types, and is used only for columns whose storage type is main or + extended. (See <xref linkend="sql-altertable"/> for information on + column storage types.) Setting this property for a partitioned table + has no direct effect, because such tables have no storage of their own, + but the configured value is inherited by newly-created partitions. + The supported compression methods are <literal>pglz</literal> and + <literal>lz4</literal>. <literal>lz4</literal> is available only if + <literal>--with-lz4</literal> was used when building + <productname>PostgreSQL</productname>. The default is <literal>pglz</literal>. </para> </listitem> diff --git a/src/backend/access/common/detoast.c b/src/backend/access/common/detoast.c index b78d49167b..95d5b1c12a 100644 --- a/src/backend/access/common/detoast.c +++ b/src/backend/access/common/detoast.c @@ -477,8 +477,8 @@ toast_get_compression_oid(struct varlena *attr) return InvalidOid; /* - * Just fetch the toast compress header to know the compression method - * in the compressed data. + * Fetch just enough of the value to examine the compression header, + * so that we can find out the compression method. */ attr = toast_fetch_datum_slice(attr, 0, VARHDRSZ_COMPRESS); } @@ -503,7 +503,6 @@ toast_get_compression_handler(struct varlena *attr) cmid = TOAST_COMPRESS_METHOD(attr); - /* Get the handler routines for the compression method */ switch (cmid) { case PGLZ_COMPRESSION_ID: diff --git a/src/backend/access/compression/compress_lz4.c b/src/backend/access/compression/compress_lz4.c index 1856cf7df7..3079eff7eb 100644 --- a/src/backend/access/compression/compress_lz4.c +++ b/src/backend/access/compression/compress_lz4.c @@ -23,7 +23,7 @@ /* * lz4_cmcompress - compression routine for lz4 compression method * - * Compresses source into dest using the default strategy. Returns the + * Compresses source into dest using the LZ4 defaults. Returns the * compressed varlena, or NULL if compression fails. */ static struct varlena * @@ -42,8 +42,8 @@ lz4_cmcompress(const struct varlena *value) valsize = VARSIZE_ANY_EXHDR(value); /* - * Get maximum size of the compressed data that lz4 compression may output - * and allocate the memory for holding the compressed data and the header. + * 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_COMPRESS); @@ -83,10 +83,10 @@ lz4_cmdecompress(const struct varlena *value) int32 rawsize; struct varlena *result; - /* allocate memory for holding the uncompressed data */ + /* allocate memory for the uncompressed data */ result = (struct varlena *) palloc(VARRAWSIZE_4B_C(value) + VARHDRSZ); - /* decompress data using lz4 routine */ + /* decompress the data */ rawsize = LZ4_decompress_safe((char *) value + VARHDRSZ_COMPRESS, VARDATA(result), VARSIZE(value) - VARHDRSZ_COMPRESS, diff --git a/src/backend/executor/nodeModifyTable.c b/src/backend/executor/nodeModifyTable.c index f77deee399..920d9dd0d5 100644 --- a/src/backend/executor/nodeModifyTable.c +++ b/src/backend/executor/nodeModifyTable.c @@ -2117,7 +2117,7 @@ CompareCompressionMethodAndDecompress(TupleTableSlot *slot, TupleTableSlot *newslot = *outslot; /* - * If the called has passed an invalid slot then create a new slot. + * If the caller has passed an invalid slot then create a new slot. * Otherwise, just clear the existing tuple from the slot. This slot * should be stored by the caller so that it can be reused for * decompressing the subsequent tuples. diff --git a/src/include/nodes/execnodes.h b/src/include/nodes/execnodes.h index 18e8ecfd90..d8483c36b3 100644 --- a/src/include/nodes/execnodes.h +++ b/src/include/nodes/execnodes.h @@ -1183,8 +1183,8 @@ typedef struct ModifyTableState TupleTableSlot *mt_root_tuple_slot; /* - * Slot for storing the modified tuple, incase the target attribute's - * compression method doesn't match with the source table. + * Slot for storing the modified tuple, in case the target attribute's + * compression method doesn't match that of the source table. */ TupleTableSlot *mt_decompress_tuple_slot; -- 2.17.0 --YZ5djTAD1cGYuMQK Content-Type: text/x-diff; charset=us-ascii Content-Disposition: attachment; filename="v24-0006-alter-table-set-compression.patch" ^ permalink raw reply [nested|flat] 51+ messages in thread
* [PATCH v24 05/10] fixups.patch @ 2021-02-10 21:56 Robert Haas <[email protected]> 0 siblings, 0 replies; 51+ messages in thread From: Robert Haas @ 2021-02-10 21:56 UTC (permalink / raw) --- doc/src/sgml/ddl.sgml | 3 --- doc/src/sgml/ref/create_table.sgml | 15 +++++++++++---- src/backend/access/common/detoast.c | 5 ++--- src/backend/access/compression/compress_lz4.c | 10 +++++----- src/backend/executor/nodeModifyTable.c | 2 +- src/include/nodes/execnodes.h | 4 ++-- 6 files changed, 21 insertions(+), 18 deletions(-) diff --git a/doc/src/sgml/ddl.sgml b/doc/src/sgml/ddl.sgml index 4d7ed698b9..1e9a4625cc 100644 --- a/doc/src/sgml/ddl.sgml +++ b/doc/src/sgml/ddl.sgml @@ -3762,9 +3762,6 @@ CREATE TABLE measurement ( <productname>PostgreSQL</productname> tables (or, possibly, foreign tables). It is possible to specify a tablespace and storage parameters for each partition separately. - By default, each column in a partition inherits the compression method - from parent table's column, however a different compression method can be - set for each partition. </para> <para> diff --git a/doc/src/sgml/ref/create_table.sgml b/doc/src/sgml/ref/create_table.sgml index 51a7a977a5..a4b297340f 100644 --- a/doc/src/sgml/ref/create_table.sgml +++ b/doc/src/sgml/ref/create_table.sgml @@ -997,10 +997,17 @@ WITH ( MODULUS <replaceable class="parameter">numeric_literal</replaceable>, REM <term><literal>COMPRESSION <replaceable class="parameter">compression_method</replaceable></literal></term> <listitem> <para> - This sets the compression method for a column. The supported compression - methods are <literal>pglz</literal> and <literal>lz4</literal>. - <literal>lz4</literal> is available only if <literal>--with-lz4</literal> - was used when building <productname>PostgreSQL</productname>. The default + The <literal>COMPRESSION</literal> clause sets the compression method + for a column. Compression is supported only for variable-width data + types, and is used only for columns whose storage type is main or + extended. (See <xref linkend="sql-altertable"/> for information on + column storage types.) Setting this property for a partitioned table + has no direct effect, because such tables have no storage of their own, + but the configured value is inherited by newly-created partitions. + The supported compression methods are <literal>pglz</literal> and + <literal>lz4</literal>. <literal>lz4</literal> is available only if + <literal>--with-lz4</literal> was used when building + <productname>PostgreSQL</productname>. The default is <literal>pglz</literal>. </para> </listitem> diff --git a/src/backend/access/common/detoast.c b/src/backend/access/common/detoast.c index b78d49167b..95d5b1c12a 100644 --- a/src/backend/access/common/detoast.c +++ b/src/backend/access/common/detoast.c @@ -477,8 +477,8 @@ toast_get_compression_oid(struct varlena *attr) return InvalidOid; /* - * Just fetch the toast compress header to know the compression method - * in the compressed data. + * Fetch just enough of the value to examine the compression header, + * so that we can find out the compression method. */ attr = toast_fetch_datum_slice(attr, 0, VARHDRSZ_COMPRESS); } @@ -503,7 +503,6 @@ toast_get_compression_handler(struct varlena *attr) cmid = TOAST_COMPRESS_METHOD(attr); - /* Get the handler routines for the compression method */ switch (cmid) { case PGLZ_COMPRESSION_ID: diff --git a/src/backend/access/compression/compress_lz4.c b/src/backend/access/compression/compress_lz4.c index 1856cf7df7..3079eff7eb 100644 --- a/src/backend/access/compression/compress_lz4.c +++ b/src/backend/access/compression/compress_lz4.c @@ -23,7 +23,7 @@ /* * lz4_cmcompress - compression routine for lz4 compression method * - * Compresses source into dest using the default strategy. Returns the + * Compresses source into dest using the LZ4 defaults. Returns the * compressed varlena, or NULL if compression fails. */ static struct varlena * @@ -42,8 +42,8 @@ lz4_cmcompress(const struct varlena *value) valsize = VARSIZE_ANY_EXHDR(value); /* - * Get maximum size of the compressed data that lz4 compression may output - * and allocate the memory for holding the compressed data and the header. + * 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_COMPRESS); @@ -83,10 +83,10 @@ lz4_cmdecompress(const struct varlena *value) int32 rawsize; struct varlena *result; - /* allocate memory for holding the uncompressed data */ + /* allocate memory for the uncompressed data */ result = (struct varlena *) palloc(VARRAWSIZE_4B_C(value) + VARHDRSZ); - /* decompress data using lz4 routine */ + /* decompress the data */ rawsize = LZ4_decompress_safe((char *) value + VARHDRSZ_COMPRESS, VARDATA(result), VARSIZE(value) - VARHDRSZ_COMPRESS, diff --git a/src/backend/executor/nodeModifyTable.c b/src/backend/executor/nodeModifyTable.c index f77deee399..920d9dd0d5 100644 --- a/src/backend/executor/nodeModifyTable.c +++ b/src/backend/executor/nodeModifyTable.c @@ -2117,7 +2117,7 @@ CompareCompressionMethodAndDecompress(TupleTableSlot *slot, TupleTableSlot *newslot = *outslot; /* - * If the called has passed an invalid slot then create a new slot. + * If the caller has passed an invalid slot then create a new slot. * Otherwise, just clear the existing tuple from the slot. This slot * should be stored by the caller so that it can be reused for * decompressing the subsequent tuples. diff --git a/src/include/nodes/execnodes.h b/src/include/nodes/execnodes.h index 18e8ecfd90..d8483c36b3 100644 --- a/src/include/nodes/execnodes.h +++ b/src/include/nodes/execnodes.h @@ -1183,8 +1183,8 @@ typedef struct ModifyTableState TupleTableSlot *mt_root_tuple_slot; /* - * Slot for storing the modified tuple, incase the target attribute's - * compression method doesn't match with the source table. + * Slot for storing the modified tuple, in case the target attribute's + * compression method doesn't match that of the source table. */ TupleTableSlot *mt_decompress_tuple_slot; -- 2.17.0 --m51xatjYGsM+13rf Content-Type: text/x-diff; charset=us-ascii Content-Disposition: attachment; filename="v24-0006-alter-table-set-compression.patch" ^ permalink raw reply [nested|flat] 51+ messages in thread
* [PATCH v24 5/7] fixups.patch @ 2021-02-10 21:56 Robert Haas <[email protected]> 0 siblings, 0 replies; 51+ messages in thread From: Robert Haas @ 2021-02-10 21:56 UTC (permalink / raw) --- doc/src/sgml/ddl.sgml | 3 --- doc/src/sgml/ref/create_table.sgml | 15 +++++++++++---- src/backend/access/common/detoast.c | 5 ++--- src/backend/access/compression/compress_lz4.c | 10 +++++----- src/backend/executor/nodeModifyTable.c | 2 +- src/include/nodes/execnodes.h | 4 ++-- 6 files changed, 21 insertions(+), 18 deletions(-) diff --git a/doc/src/sgml/ddl.sgml b/doc/src/sgml/ddl.sgml index 4d7ed698b9..1e9a4625cc 100644 --- a/doc/src/sgml/ddl.sgml +++ b/doc/src/sgml/ddl.sgml @@ -3762,9 +3762,6 @@ CREATE TABLE measurement ( <productname>PostgreSQL</productname> tables (or, possibly, foreign tables). It is possible to specify a tablespace and storage parameters for each partition separately. - By default, each column in a partition inherits the compression method - from parent table's column, however a different compression method can be - set for each partition. </para> <para> diff --git a/doc/src/sgml/ref/create_table.sgml b/doc/src/sgml/ref/create_table.sgml index 51a7a977a5..a4b297340f 100644 --- a/doc/src/sgml/ref/create_table.sgml +++ b/doc/src/sgml/ref/create_table.sgml @@ -997,10 +997,17 @@ WITH ( MODULUS <replaceable class="parameter">numeric_literal</replaceable>, REM <term><literal>COMPRESSION <replaceable class="parameter">compression_method</replaceable></literal></term> <listitem> <para> - This sets the compression method for a column. The supported compression - methods are <literal>pglz</literal> and <literal>lz4</literal>. - <literal>lz4</literal> is available only if <literal>--with-lz4</literal> - was used when building <productname>PostgreSQL</productname>. The default + The <literal>COMPRESSION</literal> clause sets the compression method + for a column. Compression is supported only for variable-width data + types, and is used only for columns whose storage type is main or + extended. (See <xref linkend="sql-altertable"/> for information on + column storage types.) Setting this property for a partitioned table + has no direct effect, because such tables have no storage of their own, + but the configured value is inherited by newly-created partitions. + The supported compression methods are <literal>pglz</literal> and + <literal>lz4</literal>. <literal>lz4</literal> is available only if + <literal>--with-lz4</literal> was used when building + <productname>PostgreSQL</productname>. The default is <literal>pglz</literal>. </para> </listitem> diff --git a/src/backend/access/common/detoast.c b/src/backend/access/common/detoast.c index b78d49167b..95d5b1c12a 100644 --- a/src/backend/access/common/detoast.c +++ b/src/backend/access/common/detoast.c @@ -477,8 +477,8 @@ toast_get_compression_oid(struct varlena *attr) return InvalidOid; /* - * Just fetch the toast compress header to know the compression method - * in the compressed data. + * Fetch just enough of the value to examine the compression header, + * so that we can find out the compression method. */ attr = toast_fetch_datum_slice(attr, 0, VARHDRSZ_COMPRESS); } @@ -503,7 +503,6 @@ toast_get_compression_handler(struct varlena *attr) cmid = TOAST_COMPRESS_METHOD(attr); - /* Get the handler routines for the compression method */ switch (cmid) { case PGLZ_COMPRESSION_ID: diff --git a/src/backend/access/compression/compress_lz4.c b/src/backend/access/compression/compress_lz4.c index 1856cf7df7..3079eff7eb 100644 --- a/src/backend/access/compression/compress_lz4.c +++ b/src/backend/access/compression/compress_lz4.c @@ -23,7 +23,7 @@ /* * lz4_cmcompress - compression routine for lz4 compression method * - * Compresses source into dest using the default strategy. Returns the + * Compresses source into dest using the LZ4 defaults. Returns the * compressed varlena, or NULL if compression fails. */ static struct varlena * @@ -42,8 +42,8 @@ lz4_cmcompress(const struct varlena *value) valsize = VARSIZE_ANY_EXHDR(value); /* - * Get maximum size of the compressed data that lz4 compression may output - * and allocate the memory for holding the compressed data and the header. + * 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_COMPRESS); @@ -83,10 +83,10 @@ lz4_cmdecompress(const struct varlena *value) int32 rawsize; struct varlena *result; - /* allocate memory for holding the uncompressed data */ + /* allocate memory for the uncompressed data */ result = (struct varlena *) palloc(VARRAWSIZE_4B_C(value) + VARHDRSZ); - /* decompress data using lz4 routine */ + /* decompress the data */ rawsize = LZ4_decompress_safe((char *) value + VARHDRSZ_COMPRESS, VARDATA(result), VARSIZE(value) - VARHDRSZ_COMPRESS, diff --git a/src/backend/executor/nodeModifyTable.c b/src/backend/executor/nodeModifyTable.c index f77deee399..920d9dd0d5 100644 --- a/src/backend/executor/nodeModifyTable.c +++ b/src/backend/executor/nodeModifyTable.c @@ -2117,7 +2117,7 @@ CompareCompressionMethodAndDecompress(TupleTableSlot *slot, TupleTableSlot *newslot = *outslot; /* - * If the called has passed an invalid slot then create a new slot. + * If the caller has passed an invalid slot then create a new slot. * Otherwise, just clear the existing tuple from the slot. This slot * should be stored by the caller so that it can be reused for * decompressing the subsequent tuples. diff --git a/src/include/nodes/execnodes.h b/src/include/nodes/execnodes.h index 18e8ecfd90..d8483c36b3 100644 --- a/src/include/nodes/execnodes.h +++ b/src/include/nodes/execnodes.h @@ -1183,8 +1183,8 @@ typedef struct ModifyTableState TupleTableSlot *mt_root_tuple_slot; /* - * Slot for storing the modified tuple, incase the target attribute's - * compression method doesn't match with the source table. + * Slot for storing the modified tuple, in case the target attribute's + * compression method doesn't match that of the source table. */ TupleTableSlot *mt_decompress_tuple_slot; -- 2.17.0 --YZ5djTAD1cGYuMQK Content-Type: text/x-diff; charset=us-ascii Content-Disposition: attachment; filename="v24-0006-alter-table-set-compression.patch" ^ permalink raw reply [nested|flat] 51+ messages in thread
* [PATCH v24 05/10] fixups.patch @ 2021-02-10 21:56 Robert Haas <[email protected]> 0 siblings, 0 replies; 51+ messages in thread From: Robert Haas @ 2021-02-10 21:56 UTC (permalink / raw) --- doc/src/sgml/ddl.sgml | 3 --- doc/src/sgml/ref/create_table.sgml | 15 +++++++++++---- src/backend/access/common/detoast.c | 5 ++--- src/backend/access/compression/compress_lz4.c | 10 +++++----- src/backend/executor/nodeModifyTable.c | 2 +- src/include/nodes/execnodes.h | 4 ++-- 6 files changed, 21 insertions(+), 18 deletions(-) diff --git a/doc/src/sgml/ddl.sgml b/doc/src/sgml/ddl.sgml index 4d7ed698b9..1e9a4625cc 100644 --- a/doc/src/sgml/ddl.sgml +++ b/doc/src/sgml/ddl.sgml @@ -3762,9 +3762,6 @@ CREATE TABLE measurement ( <productname>PostgreSQL</productname> tables (or, possibly, foreign tables). It is possible to specify a tablespace and storage parameters for each partition separately. - By default, each column in a partition inherits the compression method - from parent table's column, however a different compression method can be - set for each partition. </para> <para> diff --git a/doc/src/sgml/ref/create_table.sgml b/doc/src/sgml/ref/create_table.sgml index 51a7a977a5..a4b297340f 100644 --- a/doc/src/sgml/ref/create_table.sgml +++ b/doc/src/sgml/ref/create_table.sgml @@ -997,10 +997,17 @@ WITH ( MODULUS <replaceable class="parameter">numeric_literal</replaceable>, REM <term><literal>COMPRESSION <replaceable class="parameter">compression_method</replaceable></literal></term> <listitem> <para> - This sets the compression method for a column. The supported compression - methods are <literal>pglz</literal> and <literal>lz4</literal>. - <literal>lz4</literal> is available only if <literal>--with-lz4</literal> - was used when building <productname>PostgreSQL</productname>. The default + The <literal>COMPRESSION</literal> clause sets the compression method + for a column. Compression is supported only for variable-width data + types, and is used only for columns whose storage type is main or + extended. (See <xref linkend="sql-altertable"/> for information on + column storage types.) Setting this property for a partitioned table + has no direct effect, because such tables have no storage of their own, + but the configured value is inherited by newly-created partitions. + The supported compression methods are <literal>pglz</literal> and + <literal>lz4</literal>. <literal>lz4</literal> is available only if + <literal>--with-lz4</literal> was used when building + <productname>PostgreSQL</productname>. The default is <literal>pglz</literal>. </para> </listitem> diff --git a/src/backend/access/common/detoast.c b/src/backend/access/common/detoast.c index b78d49167b..95d5b1c12a 100644 --- a/src/backend/access/common/detoast.c +++ b/src/backend/access/common/detoast.c @@ -477,8 +477,8 @@ toast_get_compression_oid(struct varlena *attr) return InvalidOid; /* - * Just fetch the toast compress header to know the compression method - * in the compressed data. + * Fetch just enough of the value to examine the compression header, + * so that we can find out the compression method. */ attr = toast_fetch_datum_slice(attr, 0, VARHDRSZ_COMPRESS); } @@ -503,7 +503,6 @@ toast_get_compression_handler(struct varlena *attr) cmid = TOAST_COMPRESS_METHOD(attr); - /* Get the handler routines for the compression method */ switch (cmid) { case PGLZ_COMPRESSION_ID: diff --git a/src/backend/access/compression/compress_lz4.c b/src/backend/access/compression/compress_lz4.c index 1856cf7df7..3079eff7eb 100644 --- a/src/backend/access/compression/compress_lz4.c +++ b/src/backend/access/compression/compress_lz4.c @@ -23,7 +23,7 @@ /* * lz4_cmcompress - compression routine for lz4 compression method * - * Compresses source into dest using the default strategy. Returns the + * Compresses source into dest using the LZ4 defaults. Returns the * compressed varlena, or NULL if compression fails. */ static struct varlena * @@ -42,8 +42,8 @@ lz4_cmcompress(const struct varlena *value) valsize = VARSIZE_ANY_EXHDR(value); /* - * Get maximum size of the compressed data that lz4 compression may output - * and allocate the memory for holding the compressed data and the header. + * 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_COMPRESS); @@ -83,10 +83,10 @@ lz4_cmdecompress(const struct varlena *value) int32 rawsize; struct varlena *result; - /* allocate memory for holding the uncompressed data */ + /* allocate memory for the uncompressed data */ result = (struct varlena *) palloc(VARRAWSIZE_4B_C(value) + VARHDRSZ); - /* decompress data using lz4 routine */ + /* decompress the data */ rawsize = LZ4_decompress_safe((char *) value + VARHDRSZ_COMPRESS, VARDATA(result), VARSIZE(value) - VARHDRSZ_COMPRESS, diff --git a/src/backend/executor/nodeModifyTable.c b/src/backend/executor/nodeModifyTable.c index f77deee399..920d9dd0d5 100644 --- a/src/backend/executor/nodeModifyTable.c +++ b/src/backend/executor/nodeModifyTable.c @@ -2117,7 +2117,7 @@ CompareCompressionMethodAndDecompress(TupleTableSlot *slot, TupleTableSlot *newslot = *outslot; /* - * If the called has passed an invalid slot then create a new slot. + * If the caller has passed an invalid slot then create a new slot. * Otherwise, just clear the existing tuple from the slot. This slot * should be stored by the caller so that it can be reused for * decompressing the subsequent tuples. diff --git a/src/include/nodes/execnodes.h b/src/include/nodes/execnodes.h index 18e8ecfd90..d8483c36b3 100644 --- a/src/include/nodes/execnodes.h +++ b/src/include/nodes/execnodes.h @@ -1183,8 +1183,8 @@ typedef struct ModifyTableState TupleTableSlot *mt_root_tuple_slot; /* - * Slot for storing the modified tuple, incase the target attribute's - * compression method doesn't match with the source table. + * Slot for storing the modified tuple, in case the target attribute's + * compression method doesn't match that of the source table. */ TupleTableSlot *mt_decompress_tuple_slot; -- 2.17.0 --m51xatjYGsM+13rf Content-Type: text/x-diff; charset=us-ascii Content-Disposition: attachment; filename="v24-0006-alter-table-set-compression.patch" ^ permalink raw reply [nested|flat] 51+ messages in thread
* [PATCH v24 5/7] fixups.patch @ 2021-02-10 21:56 Robert Haas <[email protected]> 0 siblings, 0 replies; 51+ messages in thread From: Robert Haas @ 2021-02-10 21:56 UTC (permalink / raw) --- doc/src/sgml/ddl.sgml | 3 --- doc/src/sgml/ref/create_table.sgml | 15 +++++++++++---- src/backend/access/common/detoast.c | 5 ++--- src/backend/access/compression/compress_lz4.c | 10 +++++----- src/backend/executor/nodeModifyTable.c | 2 +- src/include/nodes/execnodes.h | 4 ++-- 6 files changed, 21 insertions(+), 18 deletions(-) diff --git a/doc/src/sgml/ddl.sgml b/doc/src/sgml/ddl.sgml index 4d7ed698b9..1e9a4625cc 100644 --- a/doc/src/sgml/ddl.sgml +++ b/doc/src/sgml/ddl.sgml @@ -3762,9 +3762,6 @@ CREATE TABLE measurement ( <productname>PostgreSQL</productname> tables (or, possibly, foreign tables). It is possible to specify a tablespace and storage parameters for each partition separately. - By default, each column in a partition inherits the compression method - from parent table's column, however a different compression method can be - set for each partition. </para> <para> diff --git a/doc/src/sgml/ref/create_table.sgml b/doc/src/sgml/ref/create_table.sgml index 51a7a977a5..a4b297340f 100644 --- a/doc/src/sgml/ref/create_table.sgml +++ b/doc/src/sgml/ref/create_table.sgml @@ -997,10 +997,17 @@ WITH ( MODULUS <replaceable class="parameter">numeric_literal</replaceable>, REM <term><literal>COMPRESSION <replaceable class="parameter">compression_method</replaceable></literal></term> <listitem> <para> - This sets the compression method for a column. The supported compression - methods are <literal>pglz</literal> and <literal>lz4</literal>. - <literal>lz4</literal> is available only if <literal>--with-lz4</literal> - was used when building <productname>PostgreSQL</productname>. The default + The <literal>COMPRESSION</literal> clause sets the compression method + for a column. Compression is supported only for variable-width data + types, and is used only for columns whose storage type is main or + extended. (See <xref linkend="sql-altertable"/> for information on + column storage types.) Setting this property for a partitioned table + has no direct effect, because such tables have no storage of their own, + but the configured value is inherited by newly-created partitions. + The supported compression methods are <literal>pglz</literal> and + <literal>lz4</literal>. <literal>lz4</literal> is available only if + <literal>--with-lz4</literal> was used when building + <productname>PostgreSQL</productname>. The default is <literal>pglz</literal>. </para> </listitem> diff --git a/src/backend/access/common/detoast.c b/src/backend/access/common/detoast.c index b78d49167b..95d5b1c12a 100644 --- a/src/backend/access/common/detoast.c +++ b/src/backend/access/common/detoast.c @@ -477,8 +477,8 @@ toast_get_compression_oid(struct varlena *attr) return InvalidOid; /* - * Just fetch the toast compress header to know the compression method - * in the compressed data. + * Fetch just enough of the value to examine the compression header, + * so that we can find out the compression method. */ attr = toast_fetch_datum_slice(attr, 0, VARHDRSZ_COMPRESS); } @@ -503,7 +503,6 @@ toast_get_compression_handler(struct varlena *attr) cmid = TOAST_COMPRESS_METHOD(attr); - /* Get the handler routines for the compression method */ switch (cmid) { case PGLZ_COMPRESSION_ID: diff --git a/src/backend/access/compression/compress_lz4.c b/src/backend/access/compression/compress_lz4.c index 1856cf7df7..3079eff7eb 100644 --- a/src/backend/access/compression/compress_lz4.c +++ b/src/backend/access/compression/compress_lz4.c @@ -23,7 +23,7 @@ /* * lz4_cmcompress - compression routine for lz4 compression method * - * Compresses source into dest using the default strategy. Returns the + * Compresses source into dest using the LZ4 defaults. Returns the * compressed varlena, or NULL if compression fails. */ static struct varlena * @@ -42,8 +42,8 @@ lz4_cmcompress(const struct varlena *value) valsize = VARSIZE_ANY_EXHDR(value); /* - * Get maximum size of the compressed data that lz4 compression may output - * and allocate the memory for holding the compressed data and the header. + * 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_COMPRESS); @@ -83,10 +83,10 @@ lz4_cmdecompress(const struct varlena *value) int32 rawsize; struct varlena *result; - /* allocate memory for holding the uncompressed data */ + /* allocate memory for the uncompressed data */ result = (struct varlena *) palloc(VARRAWSIZE_4B_C(value) + VARHDRSZ); - /* decompress data using lz4 routine */ + /* decompress the data */ rawsize = LZ4_decompress_safe((char *) value + VARHDRSZ_COMPRESS, VARDATA(result), VARSIZE(value) - VARHDRSZ_COMPRESS, diff --git a/src/backend/executor/nodeModifyTable.c b/src/backend/executor/nodeModifyTable.c index f77deee399..920d9dd0d5 100644 --- a/src/backend/executor/nodeModifyTable.c +++ b/src/backend/executor/nodeModifyTable.c @@ -2117,7 +2117,7 @@ CompareCompressionMethodAndDecompress(TupleTableSlot *slot, TupleTableSlot *newslot = *outslot; /* - * If the called has passed an invalid slot then create a new slot. + * If the caller has passed an invalid slot then create a new slot. * Otherwise, just clear the existing tuple from the slot. This slot * should be stored by the caller so that it can be reused for * decompressing the subsequent tuples. diff --git a/src/include/nodes/execnodes.h b/src/include/nodes/execnodes.h index 18e8ecfd90..d8483c36b3 100644 --- a/src/include/nodes/execnodes.h +++ b/src/include/nodes/execnodes.h @@ -1183,8 +1183,8 @@ typedef struct ModifyTableState TupleTableSlot *mt_root_tuple_slot; /* - * Slot for storing the modified tuple, incase the target attribute's - * compression method doesn't match with the source table. + * Slot for storing the modified tuple, in case the target attribute's + * compression method doesn't match that of the source table. */ TupleTableSlot *mt_decompress_tuple_slot; -- 2.17.0 --YZ5djTAD1cGYuMQK Content-Type: text/x-diff; charset=us-ascii Content-Disposition: attachment; filename="v24-0006-alter-table-set-compression.patch" ^ permalink raw reply [nested|flat] 51+ messages in thread
* [PATCH v24 05/10] fixups.patch @ 2021-02-10 21:56 Robert Haas <[email protected]> 0 siblings, 0 replies; 51+ messages in thread From: Robert Haas @ 2021-02-10 21:56 UTC (permalink / raw) --- doc/src/sgml/ddl.sgml | 3 --- doc/src/sgml/ref/create_table.sgml | 15 +++++++++++---- src/backend/access/common/detoast.c | 5 ++--- src/backend/access/compression/compress_lz4.c | 10 +++++----- src/backend/executor/nodeModifyTable.c | 2 +- src/include/nodes/execnodes.h | 4 ++-- 6 files changed, 21 insertions(+), 18 deletions(-) diff --git a/doc/src/sgml/ddl.sgml b/doc/src/sgml/ddl.sgml index 4d7ed698b9..1e9a4625cc 100644 --- a/doc/src/sgml/ddl.sgml +++ b/doc/src/sgml/ddl.sgml @@ -3762,9 +3762,6 @@ CREATE TABLE measurement ( <productname>PostgreSQL</productname> tables (or, possibly, foreign tables). It is possible to specify a tablespace and storage parameters for each partition separately. - By default, each column in a partition inherits the compression method - from parent table's column, however a different compression method can be - set for each partition. </para> <para> diff --git a/doc/src/sgml/ref/create_table.sgml b/doc/src/sgml/ref/create_table.sgml index 51a7a977a5..a4b297340f 100644 --- a/doc/src/sgml/ref/create_table.sgml +++ b/doc/src/sgml/ref/create_table.sgml @@ -997,10 +997,17 @@ WITH ( MODULUS <replaceable class="parameter">numeric_literal</replaceable>, REM <term><literal>COMPRESSION <replaceable class="parameter">compression_method</replaceable></literal></term> <listitem> <para> - This sets the compression method for a column. The supported compression - methods are <literal>pglz</literal> and <literal>lz4</literal>. - <literal>lz4</literal> is available only if <literal>--with-lz4</literal> - was used when building <productname>PostgreSQL</productname>. The default + The <literal>COMPRESSION</literal> clause sets the compression method + for a column. Compression is supported only for variable-width data + types, and is used only for columns whose storage type is main or + extended. (See <xref linkend="sql-altertable"/> for information on + column storage types.) Setting this property for a partitioned table + has no direct effect, because such tables have no storage of their own, + but the configured value is inherited by newly-created partitions. + The supported compression methods are <literal>pglz</literal> and + <literal>lz4</literal>. <literal>lz4</literal> is available only if + <literal>--with-lz4</literal> was used when building + <productname>PostgreSQL</productname>. The default is <literal>pglz</literal>. </para> </listitem> diff --git a/src/backend/access/common/detoast.c b/src/backend/access/common/detoast.c index b78d49167b..95d5b1c12a 100644 --- a/src/backend/access/common/detoast.c +++ b/src/backend/access/common/detoast.c @@ -477,8 +477,8 @@ toast_get_compression_oid(struct varlena *attr) return InvalidOid; /* - * Just fetch the toast compress header to know the compression method - * in the compressed data. + * Fetch just enough of the value to examine the compression header, + * so that we can find out the compression method. */ attr = toast_fetch_datum_slice(attr, 0, VARHDRSZ_COMPRESS); } @@ -503,7 +503,6 @@ toast_get_compression_handler(struct varlena *attr) cmid = TOAST_COMPRESS_METHOD(attr); - /* Get the handler routines for the compression method */ switch (cmid) { case PGLZ_COMPRESSION_ID: diff --git a/src/backend/access/compression/compress_lz4.c b/src/backend/access/compression/compress_lz4.c index 1856cf7df7..3079eff7eb 100644 --- a/src/backend/access/compression/compress_lz4.c +++ b/src/backend/access/compression/compress_lz4.c @@ -23,7 +23,7 @@ /* * lz4_cmcompress - compression routine for lz4 compression method * - * Compresses source into dest using the default strategy. Returns the + * Compresses source into dest using the LZ4 defaults. Returns the * compressed varlena, or NULL if compression fails. */ static struct varlena * @@ -42,8 +42,8 @@ lz4_cmcompress(const struct varlena *value) valsize = VARSIZE_ANY_EXHDR(value); /* - * Get maximum size of the compressed data that lz4 compression may output - * and allocate the memory for holding the compressed data and the header. + * 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_COMPRESS); @@ -83,10 +83,10 @@ lz4_cmdecompress(const struct varlena *value) int32 rawsize; struct varlena *result; - /* allocate memory for holding the uncompressed data */ + /* allocate memory for the uncompressed data */ result = (struct varlena *) palloc(VARRAWSIZE_4B_C(value) + VARHDRSZ); - /* decompress data using lz4 routine */ + /* decompress the data */ rawsize = LZ4_decompress_safe((char *) value + VARHDRSZ_COMPRESS, VARDATA(result), VARSIZE(value) - VARHDRSZ_COMPRESS, diff --git a/src/backend/executor/nodeModifyTable.c b/src/backend/executor/nodeModifyTable.c index f77deee399..920d9dd0d5 100644 --- a/src/backend/executor/nodeModifyTable.c +++ b/src/backend/executor/nodeModifyTable.c @@ -2117,7 +2117,7 @@ CompareCompressionMethodAndDecompress(TupleTableSlot *slot, TupleTableSlot *newslot = *outslot; /* - * If the called has passed an invalid slot then create a new slot. + * If the caller has passed an invalid slot then create a new slot. * Otherwise, just clear the existing tuple from the slot. This slot * should be stored by the caller so that it can be reused for * decompressing the subsequent tuples. diff --git a/src/include/nodes/execnodes.h b/src/include/nodes/execnodes.h index 18e8ecfd90..d8483c36b3 100644 --- a/src/include/nodes/execnodes.h +++ b/src/include/nodes/execnodes.h @@ -1183,8 +1183,8 @@ typedef struct ModifyTableState TupleTableSlot *mt_root_tuple_slot; /* - * Slot for storing the modified tuple, incase the target attribute's - * compression method doesn't match with the source table. + * Slot for storing the modified tuple, in case the target attribute's + * compression method doesn't match that of the source table. */ TupleTableSlot *mt_decompress_tuple_slot; -- 2.17.0 --m51xatjYGsM+13rf Content-Type: text/x-diff; charset=us-ascii Content-Disposition: attachment; filename="v24-0006-alter-table-set-compression.patch" ^ permalink raw reply [nested|flat] 51+ messages in thread
* [PATCH v24 5/7] fixups.patch @ 2021-02-10 21:56 Robert Haas <[email protected]> 0 siblings, 0 replies; 51+ messages in thread From: Robert Haas @ 2021-02-10 21:56 UTC (permalink / raw) --- doc/src/sgml/ddl.sgml | 3 --- doc/src/sgml/ref/create_table.sgml | 15 +++++++++++---- src/backend/access/common/detoast.c | 5 ++--- src/backend/access/compression/compress_lz4.c | 10 +++++----- src/backend/executor/nodeModifyTable.c | 2 +- src/include/nodes/execnodes.h | 4 ++-- 6 files changed, 21 insertions(+), 18 deletions(-) diff --git a/doc/src/sgml/ddl.sgml b/doc/src/sgml/ddl.sgml index 4d7ed698b9..1e9a4625cc 100644 --- a/doc/src/sgml/ddl.sgml +++ b/doc/src/sgml/ddl.sgml @@ -3762,9 +3762,6 @@ CREATE TABLE measurement ( <productname>PostgreSQL</productname> tables (or, possibly, foreign tables). It is possible to specify a tablespace and storage parameters for each partition separately. - By default, each column in a partition inherits the compression method - from parent table's column, however a different compression method can be - set for each partition. </para> <para> diff --git a/doc/src/sgml/ref/create_table.sgml b/doc/src/sgml/ref/create_table.sgml index 51a7a977a5..a4b297340f 100644 --- a/doc/src/sgml/ref/create_table.sgml +++ b/doc/src/sgml/ref/create_table.sgml @@ -997,10 +997,17 @@ WITH ( MODULUS <replaceable class="parameter">numeric_literal</replaceable>, REM <term><literal>COMPRESSION <replaceable class="parameter">compression_method</replaceable></literal></term> <listitem> <para> - This sets the compression method for a column. The supported compression - methods are <literal>pglz</literal> and <literal>lz4</literal>. - <literal>lz4</literal> is available only if <literal>--with-lz4</literal> - was used when building <productname>PostgreSQL</productname>. The default + The <literal>COMPRESSION</literal> clause sets the compression method + for a column. Compression is supported only for variable-width data + types, and is used only for columns whose storage type is main or + extended. (See <xref linkend="sql-altertable"/> for information on + column storage types.) Setting this property for a partitioned table + has no direct effect, because such tables have no storage of their own, + but the configured value is inherited by newly-created partitions. + The supported compression methods are <literal>pglz</literal> and + <literal>lz4</literal>. <literal>lz4</literal> is available only if + <literal>--with-lz4</literal> was used when building + <productname>PostgreSQL</productname>. The default is <literal>pglz</literal>. </para> </listitem> diff --git a/src/backend/access/common/detoast.c b/src/backend/access/common/detoast.c index b78d49167b..95d5b1c12a 100644 --- a/src/backend/access/common/detoast.c +++ b/src/backend/access/common/detoast.c @@ -477,8 +477,8 @@ toast_get_compression_oid(struct varlena *attr) return InvalidOid; /* - * Just fetch the toast compress header to know the compression method - * in the compressed data. + * Fetch just enough of the value to examine the compression header, + * so that we can find out the compression method. */ attr = toast_fetch_datum_slice(attr, 0, VARHDRSZ_COMPRESS); } @@ -503,7 +503,6 @@ toast_get_compression_handler(struct varlena *attr) cmid = TOAST_COMPRESS_METHOD(attr); - /* Get the handler routines for the compression method */ switch (cmid) { case PGLZ_COMPRESSION_ID: diff --git a/src/backend/access/compression/compress_lz4.c b/src/backend/access/compression/compress_lz4.c index 1856cf7df7..3079eff7eb 100644 --- a/src/backend/access/compression/compress_lz4.c +++ b/src/backend/access/compression/compress_lz4.c @@ -23,7 +23,7 @@ /* * lz4_cmcompress - compression routine for lz4 compression method * - * Compresses source into dest using the default strategy. Returns the + * Compresses source into dest using the LZ4 defaults. Returns the * compressed varlena, or NULL if compression fails. */ static struct varlena * @@ -42,8 +42,8 @@ lz4_cmcompress(const struct varlena *value) valsize = VARSIZE_ANY_EXHDR(value); /* - * Get maximum size of the compressed data that lz4 compression may output - * and allocate the memory for holding the compressed data and the header. + * 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_COMPRESS); @@ -83,10 +83,10 @@ lz4_cmdecompress(const struct varlena *value) int32 rawsize; struct varlena *result; - /* allocate memory for holding the uncompressed data */ + /* allocate memory for the uncompressed data */ result = (struct varlena *) palloc(VARRAWSIZE_4B_C(value) + VARHDRSZ); - /* decompress data using lz4 routine */ + /* decompress the data */ rawsize = LZ4_decompress_safe((char *) value + VARHDRSZ_COMPRESS, VARDATA(result), VARSIZE(value) - VARHDRSZ_COMPRESS, diff --git a/src/backend/executor/nodeModifyTable.c b/src/backend/executor/nodeModifyTable.c index f77deee399..920d9dd0d5 100644 --- a/src/backend/executor/nodeModifyTable.c +++ b/src/backend/executor/nodeModifyTable.c @@ -2117,7 +2117,7 @@ CompareCompressionMethodAndDecompress(TupleTableSlot *slot, TupleTableSlot *newslot = *outslot; /* - * If the called has passed an invalid slot then create a new slot. + * If the caller has passed an invalid slot then create a new slot. * Otherwise, just clear the existing tuple from the slot. This slot * should be stored by the caller so that it can be reused for * decompressing the subsequent tuples. diff --git a/src/include/nodes/execnodes.h b/src/include/nodes/execnodes.h index 18e8ecfd90..d8483c36b3 100644 --- a/src/include/nodes/execnodes.h +++ b/src/include/nodes/execnodes.h @@ -1183,8 +1183,8 @@ typedef struct ModifyTableState TupleTableSlot *mt_root_tuple_slot; /* - * Slot for storing the modified tuple, incase the target attribute's - * compression method doesn't match with the source table. + * Slot for storing the modified tuple, in case the target attribute's + * compression method doesn't match that of the source table. */ TupleTableSlot *mt_decompress_tuple_slot; -- 2.17.0 --YZ5djTAD1cGYuMQK Content-Type: text/x-diff; charset=us-ascii Content-Disposition: attachment; filename="v24-0006-alter-table-set-compression.patch" ^ permalink raw reply [nested|flat] 51+ messages in thread
* [PATCH v24 05/10] fixups.patch @ 2021-02-10 21:56 Robert Haas <[email protected]> 0 siblings, 0 replies; 51+ messages in thread From: Robert Haas @ 2021-02-10 21:56 UTC (permalink / raw) --- doc/src/sgml/ddl.sgml | 3 --- doc/src/sgml/ref/create_table.sgml | 15 +++++++++++---- src/backend/access/common/detoast.c | 5 ++--- src/backend/access/compression/compress_lz4.c | 10 +++++----- src/backend/executor/nodeModifyTable.c | 2 +- src/include/nodes/execnodes.h | 4 ++-- 6 files changed, 21 insertions(+), 18 deletions(-) diff --git a/doc/src/sgml/ddl.sgml b/doc/src/sgml/ddl.sgml index 4d7ed698b9..1e9a4625cc 100644 --- a/doc/src/sgml/ddl.sgml +++ b/doc/src/sgml/ddl.sgml @@ -3762,9 +3762,6 @@ CREATE TABLE measurement ( <productname>PostgreSQL</productname> tables (or, possibly, foreign tables). It is possible to specify a tablespace and storage parameters for each partition separately. - By default, each column in a partition inherits the compression method - from parent table's column, however a different compression method can be - set for each partition. </para> <para> diff --git a/doc/src/sgml/ref/create_table.sgml b/doc/src/sgml/ref/create_table.sgml index 51a7a977a5..a4b297340f 100644 --- a/doc/src/sgml/ref/create_table.sgml +++ b/doc/src/sgml/ref/create_table.sgml @@ -997,10 +997,17 @@ WITH ( MODULUS <replaceable class="parameter">numeric_literal</replaceable>, REM <term><literal>COMPRESSION <replaceable class="parameter">compression_method</replaceable></literal></term> <listitem> <para> - This sets the compression method for a column. The supported compression - methods are <literal>pglz</literal> and <literal>lz4</literal>. - <literal>lz4</literal> is available only if <literal>--with-lz4</literal> - was used when building <productname>PostgreSQL</productname>. The default + The <literal>COMPRESSION</literal> clause sets the compression method + for a column. Compression is supported only for variable-width data + types, and is used only for columns whose storage type is main or + extended. (See <xref linkend="sql-altertable"/> for information on + column storage types.) Setting this property for a partitioned table + has no direct effect, because such tables have no storage of their own, + but the configured value is inherited by newly-created partitions. + The supported compression methods are <literal>pglz</literal> and + <literal>lz4</literal>. <literal>lz4</literal> is available only if + <literal>--with-lz4</literal> was used when building + <productname>PostgreSQL</productname>. The default is <literal>pglz</literal>. </para> </listitem> diff --git a/src/backend/access/common/detoast.c b/src/backend/access/common/detoast.c index b78d49167b..95d5b1c12a 100644 --- a/src/backend/access/common/detoast.c +++ b/src/backend/access/common/detoast.c @@ -477,8 +477,8 @@ toast_get_compression_oid(struct varlena *attr) return InvalidOid; /* - * Just fetch the toast compress header to know the compression method - * in the compressed data. + * Fetch just enough of the value to examine the compression header, + * so that we can find out the compression method. */ attr = toast_fetch_datum_slice(attr, 0, VARHDRSZ_COMPRESS); } @@ -503,7 +503,6 @@ toast_get_compression_handler(struct varlena *attr) cmid = TOAST_COMPRESS_METHOD(attr); - /* Get the handler routines for the compression method */ switch (cmid) { case PGLZ_COMPRESSION_ID: diff --git a/src/backend/access/compression/compress_lz4.c b/src/backend/access/compression/compress_lz4.c index 1856cf7df7..3079eff7eb 100644 --- a/src/backend/access/compression/compress_lz4.c +++ b/src/backend/access/compression/compress_lz4.c @@ -23,7 +23,7 @@ /* * lz4_cmcompress - compression routine for lz4 compression method * - * Compresses source into dest using the default strategy. Returns the + * Compresses source into dest using the LZ4 defaults. Returns the * compressed varlena, or NULL if compression fails. */ static struct varlena * @@ -42,8 +42,8 @@ lz4_cmcompress(const struct varlena *value) valsize = VARSIZE_ANY_EXHDR(value); /* - * Get maximum size of the compressed data that lz4 compression may output - * and allocate the memory for holding the compressed data and the header. + * 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_COMPRESS); @@ -83,10 +83,10 @@ lz4_cmdecompress(const struct varlena *value) int32 rawsize; struct varlena *result; - /* allocate memory for holding the uncompressed data */ + /* allocate memory for the uncompressed data */ result = (struct varlena *) palloc(VARRAWSIZE_4B_C(value) + VARHDRSZ); - /* decompress data using lz4 routine */ + /* decompress the data */ rawsize = LZ4_decompress_safe((char *) value + VARHDRSZ_COMPRESS, VARDATA(result), VARSIZE(value) - VARHDRSZ_COMPRESS, diff --git a/src/backend/executor/nodeModifyTable.c b/src/backend/executor/nodeModifyTable.c index f77deee399..920d9dd0d5 100644 --- a/src/backend/executor/nodeModifyTable.c +++ b/src/backend/executor/nodeModifyTable.c @@ -2117,7 +2117,7 @@ CompareCompressionMethodAndDecompress(TupleTableSlot *slot, TupleTableSlot *newslot = *outslot; /* - * If the called has passed an invalid slot then create a new slot. + * If the caller has passed an invalid slot then create a new slot. * Otherwise, just clear the existing tuple from the slot. This slot * should be stored by the caller so that it can be reused for * decompressing the subsequent tuples. diff --git a/src/include/nodes/execnodes.h b/src/include/nodes/execnodes.h index 18e8ecfd90..d8483c36b3 100644 --- a/src/include/nodes/execnodes.h +++ b/src/include/nodes/execnodes.h @@ -1183,8 +1183,8 @@ typedef struct ModifyTableState TupleTableSlot *mt_root_tuple_slot; /* - * Slot for storing the modified tuple, incase the target attribute's - * compression method doesn't match with the source table. + * Slot for storing the modified tuple, in case the target attribute's + * compression method doesn't match that of the source table. */ TupleTableSlot *mt_decompress_tuple_slot; -- 2.17.0 --m51xatjYGsM+13rf Content-Type: text/x-diff; charset=us-ascii Content-Disposition: attachment; filename="v24-0006-alter-table-set-compression.patch" ^ permalink raw reply [nested|flat] 51+ messages in thread
* [PATCH v24 5/7] fixups.patch @ 2021-02-10 21:56 Robert Haas <[email protected]> 0 siblings, 0 replies; 51+ messages in thread From: Robert Haas @ 2021-02-10 21:56 UTC (permalink / raw) --- doc/src/sgml/ddl.sgml | 3 --- doc/src/sgml/ref/create_table.sgml | 15 +++++++++++---- src/backend/access/common/detoast.c | 5 ++--- src/backend/access/compression/compress_lz4.c | 10 +++++----- src/backend/executor/nodeModifyTable.c | 2 +- src/include/nodes/execnodes.h | 4 ++-- 6 files changed, 21 insertions(+), 18 deletions(-) diff --git a/doc/src/sgml/ddl.sgml b/doc/src/sgml/ddl.sgml index 4d7ed698b9..1e9a4625cc 100644 --- a/doc/src/sgml/ddl.sgml +++ b/doc/src/sgml/ddl.sgml @@ -3762,9 +3762,6 @@ CREATE TABLE measurement ( <productname>PostgreSQL</productname> tables (or, possibly, foreign tables). It is possible to specify a tablespace and storage parameters for each partition separately. - By default, each column in a partition inherits the compression method - from parent table's column, however a different compression method can be - set for each partition. </para> <para> diff --git a/doc/src/sgml/ref/create_table.sgml b/doc/src/sgml/ref/create_table.sgml index 51a7a977a5..a4b297340f 100644 --- a/doc/src/sgml/ref/create_table.sgml +++ b/doc/src/sgml/ref/create_table.sgml @@ -997,10 +997,17 @@ WITH ( MODULUS <replaceable class="parameter">numeric_literal</replaceable>, REM <term><literal>COMPRESSION <replaceable class="parameter">compression_method</replaceable></literal></term> <listitem> <para> - This sets the compression method for a column. The supported compression - methods are <literal>pglz</literal> and <literal>lz4</literal>. - <literal>lz4</literal> is available only if <literal>--with-lz4</literal> - was used when building <productname>PostgreSQL</productname>. The default + The <literal>COMPRESSION</literal> clause sets the compression method + for a column. Compression is supported only for variable-width data + types, and is used only for columns whose storage type is main or + extended. (See <xref linkend="sql-altertable"/> for information on + column storage types.) Setting this property for a partitioned table + has no direct effect, because such tables have no storage of their own, + but the configured value is inherited by newly-created partitions. + The supported compression methods are <literal>pglz</literal> and + <literal>lz4</literal>. <literal>lz4</literal> is available only if + <literal>--with-lz4</literal> was used when building + <productname>PostgreSQL</productname>. The default is <literal>pglz</literal>. </para> </listitem> diff --git a/src/backend/access/common/detoast.c b/src/backend/access/common/detoast.c index b78d49167b..95d5b1c12a 100644 --- a/src/backend/access/common/detoast.c +++ b/src/backend/access/common/detoast.c @@ -477,8 +477,8 @@ toast_get_compression_oid(struct varlena *attr) return InvalidOid; /* - * Just fetch the toast compress header to know the compression method - * in the compressed data. + * Fetch just enough of the value to examine the compression header, + * so that we can find out the compression method. */ attr = toast_fetch_datum_slice(attr, 0, VARHDRSZ_COMPRESS); } @@ -503,7 +503,6 @@ toast_get_compression_handler(struct varlena *attr) cmid = TOAST_COMPRESS_METHOD(attr); - /* Get the handler routines for the compression method */ switch (cmid) { case PGLZ_COMPRESSION_ID: diff --git a/src/backend/access/compression/compress_lz4.c b/src/backend/access/compression/compress_lz4.c index 1856cf7df7..3079eff7eb 100644 --- a/src/backend/access/compression/compress_lz4.c +++ b/src/backend/access/compression/compress_lz4.c @@ -23,7 +23,7 @@ /* * lz4_cmcompress - compression routine for lz4 compression method * - * Compresses source into dest using the default strategy. Returns the + * Compresses source into dest using the LZ4 defaults. Returns the * compressed varlena, or NULL if compression fails. */ static struct varlena * @@ -42,8 +42,8 @@ lz4_cmcompress(const struct varlena *value) valsize = VARSIZE_ANY_EXHDR(value); /* - * Get maximum size of the compressed data that lz4 compression may output - * and allocate the memory for holding the compressed data and the header. + * 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_COMPRESS); @@ -83,10 +83,10 @@ lz4_cmdecompress(const struct varlena *value) int32 rawsize; struct varlena *result; - /* allocate memory for holding the uncompressed data */ + /* allocate memory for the uncompressed data */ result = (struct varlena *) palloc(VARRAWSIZE_4B_C(value) + VARHDRSZ); - /* decompress data using lz4 routine */ + /* decompress the data */ rawsize = LZ4_decompress_safe((char *) value + VARHDRSZ_COMPRESS, VARDATA(result), VARSIZE(value) - VARHDRSZ_COMPRESS, diff --git a/src/backend/executor/nodeModifyTable.c b/src/backend/executor/nodeModifyTable.c index f77deee399..920d9dd0d5 100644 --- a/src/backend/executor/nodeModifyTable.c +++ b/src/backend/executor/nodeModifyTable.c @@ -2117,7 +2117,7 @@ CompareCompressionMethodAndDecompress(TupleTableSlot *slot, TupleTableSlot *newslot = *outslot; /* - * If the called has passed an invalid slot then create a new slot. + * If the caller has passed an invalid slot then create a new slot. * Otherwise, just clear the existing tuple from the slot. This slot * should be stored by the caller so that it can be reused for * decompressing the subsequent tuples. diff --git a/src/include/nodes/execnodes.h b/src/include/nodes/execnodes.h index 18e8ecfd90..d8483c36b3 100644 --- a/src/include/nodes/execnodes.h +++ b/src/include/nodes/execnodes.h @@ -1183,8 +1183,8 @@ typedef struct ModifyTableState TupleTableSlot *mt_root_tuple_slot; /* - * Slot for storing the modified tuple, incase the target attribute's - * compression method doesn't match with the source table. + * Slot for storing the modified tuple, in case the target attribute's + * compression method doesn't match that of the source table. */ TupleTableSlot *mt_decompress_tuple_slot; -- 2.17.0 --YZ5djTAD1cGYuMQK Content-Type: text/x-diff; charset=us-ascii Content-Disposition: attachment; filename="v24-0006-alter-table-set-compression.patch" ^ permalink raw reply [nested|flat] 51+ messages in thread
* [PATCH v24 05/10] fixups.patch @ 2021-02-10 21:56 Robert Haas <[email protected]> 0 siblings, 0 replies; 51+ messages in thread From: Robert Haas @ 2021-02-10 21:56 UTC (permalink / raw) --- doc/src/sgml/ddl.sgml | 3 --- doc/src/sgml/ref/create_table.sgml | 15 +++++++++++---- src/backend/access/common/detoast.c | 5 ++--- src/backend/access/compression/compress_lz4.c | 10 +++++----- src/backend/executor/nodeModifyTable.c | 2 +- src/include/nodes/execnodes.h | 4 ++-- 6 files changed, 21 insertions(+), 18 deletions(-) diff --git a/doc/src/sgml/ddl.sgml b/doc/src/sgml/ddl.sgml index 4d7ed698b9..1e9a4625cc 100644 --- a/doc/src/sgml/ddl.sgml +++ b/doc/src/sgml/ddl.sgml @@ -3762,9 +3762,6 @@ CREATE TABLE measurement ( <productname>PostgreSQL</productname> tables (or, possibly, foreign tables). It is possible to specify a tablespace and storage parameters for each partition separately. - By default, each column in a partition inherits the compression method - from parent table's column, however a different compression method can be - set for each partition. </para> <para> diff --git a/doc/src/sgml/ref/create_table.sgml b/doc/src/sgml/ref/create_table.sgml index 51a7a977a5..a4b297340f 100644 --- a/doc/src/sgml/ref/create_table.sgml +++ b/doc/src/sgml/ref/create_table.sgml @@ -997,10 +997,17 @@ WITH ( MODULUS <replaceable class="parameter">numeric_literal</replaceable>, REM <term><literal>COMPRESSION <replaceable class="parameter">compression_method</replaceable></literal></term> <listitem> <para> - This sets the compression method for a column. The supported compression - methods are <literal>pglz</literal> and <literal>lz4</literal>. - <literal>lz4</literal> is available only if <literal>--with-lz4</literal> - was used when building <productname>PostgreSQL</productname>. The default + The <literal>COMPRESSION</literal> clause sets the compression method + for a column. Compression is supported only for variable-width data + types, and is used only for columns whose storage type is main or + extended. (See <xref linkend="sql-altertable"/> for information on + column storage types.) Setting this property for a partitioned table + has no direct effect, because such tables have no storage of their own, + but the configured value is inherited by newly-created partitions. + The supported compression methods are <literal>pglz</literal> and + <literal>lz4</literal>. <literal>lz4</literal> is available only if + <literal>--with-lz4</literal> was used when building + <productname>PostgreSQL</productname>. The default is <literal>pglz</literal>. </para> </listitem> diff --git a/src/backend/access/common/detoast.c b/src/backend/access/common/detoast.c index b78d49167b..95d5b1c12a 100644 --- a/src/backend/access/common/detoast.c +++ b/src/backend/access/common/detoast.c @@ -477,8 +477,8 @@ toast_get_compression_oid(struct varlena *attr) return InvalidOid; /* - * Just fetch the toast compress header to know the compression method - * in the compressed data. + * Fetch just enough of the value to examine the compression header, + * so that we can find out the compression method. */ attr = toast_fetch_datum_slice(attr, 0, VARHDRSZ_COMPRESS); } @@ -503,7 +503,6 @@ toast_get_compression_handler(struct varlena *attr) cmid = TOAST_COMPRESS_METHOD(attr); - /* Get the handler routines for the compression method */ switch (cmid) { case PGLZ_COMPRESSION_ID: diff --git a/src/backend/access/compression/compress_lz4.c b/src/backend/access/compression/compress_lz4.c index 1856cf7df7..3079eff7eb 100644 --- a/src/backend/access/compression/compress_lz4.c +++ b/src/backend/access/compression/compress_lz4.c @@ -23,7 +23,7 @@ /* * lz4_cmcompress - compression routine for lz4 compression method * - * Compresses source into dest using the default strategy. Returns the + * Compresses source into dest using the LZ4 defaults. Returns the * compressed varlena, or NULL if compression fails. */ static struct varlena * @@ -42,8 +42,8 @@ lz4_cmcompress(const struct varlena *value) valsize = VARSIZE_ANY_EXHDR(value); /* - * Get maximum size of the compressed data that lz4 compression may output - * and allocate the memory for holding the compressed data and the header. + * 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_COMPRESS); @@ -83,10 +83,10 @@ lz4_cmdecompress(const struct varlena *value) int32 rawsize; struct varlena *result; - /* allocate memory for holding the uncompressed data */ + /* allocate memory for the uncompressed data */ result = (struct varlena *) palloc(VARRAWSIZE_4B_C(value) + VARHDRSZ); - /* decompress data using lz4 routine */ + /* decompress the data */ rawsize = LZ4_decompress_safe((char *) value + VARHDRSZ_COMPRESS, VARDATA(result), VARSIZE(value) - VARHDRSZ_COMPRESS, diff --git a/src/backend/executor/nodeModifyTable.c b/src/backend/executor/nodeModifyTable.c index f77deee399..920d9dd0d5 100644 --- a/src/backend/executor/nodeModifyTable.c +++ b/src/backend/executor/nodeModifyTable.c @@ -2117,7 +2117,7 @@ CompareCompressionMethodAndDecompress(TupleTableSlot *slot, TupleTableSlot *newslot = *outslot; /* - * If the called has passed an invalid slot then create a new slot. + * If the caller has passed an invalid slot then create a new slot. * Otherwise, just clear the existing tuple from the slot. This slot * should be stored by the caller so that it can be reused for * decompressing the subsequent tuples. diff --git a/src/include/nodes/execnodes.h b/src/include/nodes/execnodes.h index 18e8ecfd90..d8483c36b3 100644 --- a/src/include/nodes/execnodes.h +++ b/src/include/nodes/execnodes.h @@ -1183,8 +1183,8 @@ typedef struct ModifyTableState TupleTableSlot *mt_root_tuple_slot; /* - * Slot for storing the modified tuple, incase the target attribute's - * compression method doesn't match with the source table. + * Slot for storing the modified tuple, in case the target attribute's + * compression method doesn't match that of the source table. */ TupleTableSlot *mt_decompress_tuple_slot; -- 2.17.0 --m51xatjYGsM+13rf Content-Type: text/x-diff; charset=us-ascii Content-Disposition: attachment; filename="v24-0006-alter-table-set-compression.patch" ^ permalink raw reply [nested|flat] 51+ messages in thread
* [PATCH v24 5/7] fixups.patch @ 2021-02-10 21:56 Robert Haas <[email protected]> 0 siblings, 0 replies; 51+ messages in thread From: Robert Haas @ 2021-02-10 21:56 UTC (permalink / raw) --- doc/src/sgml/ddl.sgml | 3 --- doc/src/sgml/ref/create_table.sgml | 15 +++++++++++---- src/backend/access/common/detoast.c | 5 ++--- src/backend/access/compression/compress_lz4.c | 10 +++++----- src/backend/executor/nodeModifyTable.c | 2 +- src/include/nodes/execnodes.h | 4 ++-- 6 files changed, 21 insertions(+), 18 deletions(-) diff --git a/doc/src/sgml/ddl.sgml b/doc/src/sgml/ddl.sgml index 4d7ed698b9..1e9a4625cc 100644 --- a/doc/src/sgml/ddl.sgml +++ b/doc/src/sgml/ddl.sgml @@ -3762,9 +3762,6 @@ CREATE TABLE measurement ( <productname>PostgreSQL</productname> tables (or, possibly, foreign tables). It is possible to specify a tablespace and storage parameters for each partition separately. - By default, each column in a partition inherits the compression method - from parent table's column, however a different compression method can be - set for each partition. </para> <para> diff --git a/doc/src/sgml/ref/create_table.sgml b/doc/src/sgml/ref/create_table.sgml index 51a7a977a5..a4b297340f 100644 --- a/doc/src/sgml/ref/create_table.sgml +++ b/doc/src/sgml/ref/create_table.sgml @@ -997,10 +997,17 @@ WITH ( MODULUS <replaceable class="parameter">numeric_literal</replaceable>, REM <term><literal>COMPRESSION <replaceable class="parameter">compression_method</replaceable></literal></term> <listitem> <para> - This sets the compression method for a column. The supported compression - methods are <literal>pglz</literal> and <literal>lz4</literal>. - <literal>lz4</literal> is available only if <literal>--with-lz4</literal> - was used when building <productname>PostgreSQL</productname>. The default + The <literal>COMPRESSION</literal> clause sets the compression method + for a column. Compression is supported only for variable-width data + types, and is used only for columns whose storage type is main or + extended. (See <xref linkend="sql-altertable"/> for information on + column storage types.) Setting this property for a partitioned table + has no direct effect, because such tables have no storage of their own, + but the configured value is inherited by newly-created partitions. + The supported compression methods are <literal>pglz</literal> and + <literal>lz4</literal>. <literal>lz4</literal> is available only if + <literal>--with-lz4</literal> was used when building + <productname>PostgreSQL</productname>. The default is <literal>pglz</literal>. </para> </listitem> diff --git a/src/backend/access/common/detoast.c b/src/backend/access/common/detoast.c index b78d49167b..95d5b1c12a 100644 --- a/src/backend/access/common/detoast.c +++ b/src/backend/access/common/detoast.c @@ -477,8 +477,8 @@ toast_get_compression_oid(struct varlena *attr) return InvalidOid; /* - * Just fetch the toast compress header to know the compression method - * in the compressed data. + * Fetch just enough of the value to examine the compression header, + * so that we can find out the compression method. */ attr = toast_fetch_datum_slice(attr, 0, VARHDRSZ_COMPRESS); } @@ -503,7 +503,6 @@ toast_get_compression_handler(struct varlena *attr) cmid = TOAST_COMPRESS_METHOD(attr); - /* Get the handler routines for the compression method */ switch (cmid) { case PGLZ_COMPRESSION_ID: diff --git a/src/backend/access/compression/compress_lz4.c b/src/backend/access/compression/compress_lz4.c index 1856cf7df7..3079eff7eb 100644 --- a/src/backend/access/compression/compress_lz4.c +++ b/src/backend/access/compression/compress_lz4.c @@ -23,7 +23,7 @@ /* * lz4_cmcompress - compression routine for lz4 compression method * - * Compresses source into dest using the default strategy. Returns the + * Compresses source into dest using the LZ4 defaults. Returns the * compressed varlena, or NULL if compression fails. */ static struct varlena * @@ -42,8 +42,8 @@ lz4_cmcompress(const struct varlena *value) valsize = VARSIZE_ANY_EXHDR(value); /* - * Get maximum size of the compressed data that lz4 compression may output - * and allocate the memory for holding the compressed data and the header. + * 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_COMPRESS); @@ -83,10 +83,10 @@ lz4_cmdecompress(const struct varlena *value) int32 rawsize; struct varlena *result; - /* allocate memory for holding the uncompressed data */ + /* allocate memory for the uncompressed data */ result = (struct varlena *) palloc(VARRAWSIZE_4B_C(value) + VARHDRSZ); - /* decompress data using lz4 routine */ + /* decompress the data */ rawsize = LZ4_decompress_safe((char *) value + VARHDRSZ_COMPRESS, VARDATA(result), VARSIZE(value) - VARHDRSZ_COMPRESS, diff --git a/src/backend/executor/nodeModifyTable.c b/src/backend/executor/nodeModifyTable.c index f77deee399..920d9dd0d5 100644 --- a/src/backend/executor/nodeModifyTable.c +++ b/src/backend/executor/nodeModifyTable.c @@ -2117,7 +2117,7 @@ CompareCompressionMethodAndDecompress(TupleTableSlot *slot, TupleTableSlot *newslot = *outslot; /* - * If the called has passed an invalid slot then create a new slot. + * If the caller has passed an invalid slot then create a new slot. * Otherwise, just clear the existing tuple from the slot. This slot * should be stored by the caller so that it can be reused for * decompressing the subsequent tuples. diff --git a/src/include/nodes/execnodes.h b/src/include/nodes/execnodes.h index 18e8ecfd90..d8483c36b3 100644 --- a/src/include/nodes/execnodes.h +++ b/src/include/nodes/execnodes.h @@ -1183,8 +1183,8 @@ typedef struct ModifyTableState TupleTableSlot *mt_root_tuple_slot; /* - * Slot for storing the modified tuple, incase the target attribute's - * compression method doesn't match with the source table. + * Slot for storing the modified tuple, in case the target attribute's + * compression method doesn't match that of the source table. */ TupleTableSlot *mt_decompress_tuple_slot; -- 2.17.0 --YZ5djTAD1cGYuMQK Content-Type: text/x-diff; charset=us-ascii Content-Disposition: attachment; filename="v24-0006-alter-table-set-compression.patch" ^ permalink raw reply [nested|flat] 51+ messages in thread
* [PATCH v24 05/10] fixups.patch @ 2021-02-10 21:56 Robert Haas <[email protected]> 0 siblings, 0 replies; 51+ messages in thread From: Robert Haas @ 2021-02-10 21:56 UTC (permalink / raw) --- doc/src/sgml/ddl.sgml | 3 --- doc/src/sgml/ref/create_table.sgml | 15 +++++++++++---- src/backend/access/common/detoast.c | 5 ++--- src/backend/access/compression/compress_lz4.c | 10 +++++----- src/backend/executor/nodeModifyTable.c | 2 +- src/include/nodes/execnodes.h | 4 ++-- 6 files changed, 21 insertions(+), 18 deletions(-) diff --git a/doc/src/sgml/ddl.sgml b/doc/src/sgml/ddl.sgml index 4d7ed698b9..1e9a4625cc 100644 --- a/doc/src/sgml/ddl.sgml +++ b/doc/src/sgml/ddl.sgml @@ -3762,9 +3762,6 @@ CREATE TABLE measurement ( <productname>PostgreSQL</productname> tables (or, possibly, foreign tables). It is possible to specify a tablespace and storage parameters for each partition separately. - By default, each column in a partition inherits the compression method - from parent table's column, however a different compression method can be - set for each partition. </para> <para> diff --git a/doc/src/sgml/ref/create_table.sgml b/doc/src/sgml/ref/create_table.sgml index 51a7a977a5..a4b297340f 100644 --- a/doc/src/sgml/ref/create_table.sgml +++ b/doc/src/sgml/ref/create_table.sgml @@ -997,10 +997,17 @@ WITH ( MODULUS <replaceable class="parameter">numeric_literal</replaceable>, REM <term><literal>COMPRESSION <replaceable class="parameter">compression_method</replaceable></literal></term> <listitem> <para> - This sets the compression method for a column. The supported compression - methods are <literal>pglz</literal> and <literal>lz4</literal>. - <literal>lz4</literal> is available only if <literal>--with-lz4</literal> - was used when building <productname>PostgreSQL</productname>. The default + The <literal>COMPRESSION</literal> clause sets the compression method + for a column. Compression is supported only for variable-width data + types, and is used only for columns whose storage type is main or + extended. (See <xref linkend="sql-altertable"/> for information on + column storage types.) Setting this property for a partitioned table + has no direct effect, because such tables have no storage of their own, + but the configured value is inherited by newly-created partitions. + The supported compression methods are <literal>pglz</literal> and + <literal>lz4</literal>. <literal>lz4</literal> is available only if + <literal>--with-lz4</literal> was used when building + <productname>PostgreSQL</productname>. The default is <literal>pglz</literal>. </para> </listitem> diff --git a/src/backend/access/common/detoast.c b/src/backend/access/common/detoast.c index b78d49167b..95d5b1c12a 100644 --- a/src/backend/access/common/detoast.c +++ b/src/backend/access/common/detoast.c @@ -477,8 +477,8 @@ toast_get_compression_oid(struct varlena *attr) return InvalidOid; /* - * Just fetch the toast compress header to know the compression method - * in the compressed data. + * Fetch just enough of the value to examine the compression header, + * so that we can find out the compression method. */ attr = toast_fetch_datum_slice(attr, 0, VARHDRSZ_COMPRESS); } @@ -503,7 +503,6 @@ toast_get_compression_handler(struct varlena *attr) cmid = TOAST_COMPRESS_METHOD(attr); - /* Get the handler routines for the compression method */ switch (cmid) { case PGLZ_COMPRESSION_ID: diff --git a/src/backend/access/compression/compress_lz4.c b/src/backend/access/compression/compress_lz4.c index 1856cf7df7..3079eff7eb 100644 --- a/src/backend/access/compression/compress_lz4.c +++ b/src/backend/access/compression/compress_lz4.c @@ -23,7 +23,7 @@ /* * lz4_cmcompress - compression routine for lz4 compression method * - * Compresses source into dest using the default strategy. Returns the + * Compresses source into dest using the LZ4 defaults. Returns the * compressed varlena, or NULL if compression fails. */ static struct varlena * @@ -42,8 +42,8 @@ lz4_cmcompress(const struct varlena *value) valsize = VARSIZE_ANY_EXHDR(value); /* - * Get maximum size of the compressed data that lz4 compression may output - * and allocate the memory for holding the compressed data and the header. + * 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_COMPRESS); @@ -83,10 +83,10 @@ lz4_cmdecompress(const struct varlena *value) int32 rawsize; struct varlena *result; - /* allocate memory for holding the uncompressed data */ + /* allocate memory for the uncompressed data */ result = (struct varlena *) palloc(VARRAWSIZE_4B_C(value) + VARHDRSZ); - /* decompress data using lz4 routine */ + /* decompress the data */ rawsize = LZ4_decompress_safe((char *) value + VARHDRSZ_COMPRESS, VARDATA(result), VARSIZE(value) - VARHDRSZ_COMPRESS, diff --git a/src/backend/executor/nodeModifyTable.c b/src/backend/executor/nodeModifyTable.c index f77deee399..920d9dd0d5 100644 --- a/src/backend/executor/nodeModifyTable.c +++ b/src/backend/executor/nodeModifyTable.c @@ -2117,7 +2117,7 @@ CompareCompressionMethodAndDecompress(TupleTableSlot *slot, TupleTableSlot *newslot = *outslot; /* - * If the called has passed an invalid slot then create a new slot. + * If the caller has passed an invalid slot then create a new slot. * Otherwise, just clear the existing tuple from the slot. This slot * should be stored by the caller so that it can be reused for * decompressing the subsequent tuples. diff --git a/src/include/nodes/execnodes.h b/src/include/nodes/execnodes.h index 18e8ecfd90..d8483c36b3 100644 --- a/src/include/nodes/execnodes.h +++ b/src/include/nodes/execnodes.h @@ -1183,8 +1183,8 @@ typedef struct ModifyTableState TupleTableSlot *mt_root_tuple_slot; /* - * Slot for storing the modified tuple, incase the target attribute's - * compression method doesn't match with the source table. + * Slot for storing the modified tuple, in case the target attribute's + * compression method doesn't match that of the source table. */ TupleTableSlot *mt_decompress_tuple_slot; -- 2.17.0 --m51xatjYGsM+13rf Content-Type: text/x-diff; charset=us-ascii Content-Disposition: attachment; filename="v24-0006-alter-table-set-compression.patch" ^ permalink raw reply [nested|flat] 51+ messages in thread
* [PATCH v24 5/7] fixups.patch @ 2021-02-10 21:56 Robert Haas <[email protected]> 0 siblings, 0 replies; 51+ messages in thread From: Robert Haas @ 2021-02-10 21:56 UTC (permalink / raw) --- doc/src/sgml/ddl.sgml | 3 --- doc/src/sgml/ref/create_table.sgml | 15 +++++++++++---- src/backend/access/common/detoast.c | 5 ++--- src/backend/access/compression/compress_lz4.c | 10 +++++----- src/backend/executor/nodeModifyTable.c | 2 +- src/include/nodes/execnodes.h | 4 ++-- 6 files changed, 21 insertions(+), 18 deletions(-) diff --git a/doc/src/sgml/ddl.sgml b/doc/src/sgml/ddl.sgml index 4d7ed698b9..1e9a4625cc 100644 --- a/doc/src/sgml/ddl.sgml +++ b/doc/src/sgml/ddl.sgml @@ -3762,9 +3762,6 @@ CREATE TABLE measurement ( <productname>PostgreSQL</productname> tables (or, possibly, foreign tables). It is possible to specify a tablespace and storage parameters for each partition separately. - By default, each column in a partition inherits the compression method - from parent table's column, however a different compression method can be - set for each partition. </para> <para> diff --git a/doc/src/sgml/ref/create_table.sgml b/doc/src/sgml/ref/create_table.sgml index 51a7a977a5..a4b297340f 100644 --- a/doc/src/sgml/ref/create_table.sgml +++ b/doc/src/sgml/ref/create_table.sgml @@ -997,10 +997,17 @@ WITH ( MODULUS <replaceable class="parameter">numeric_literal</replaceable>, REM <term><literal>COMPRESSION <replaceable class="parameter">compression_method</replaceable></literal></term> <listitem> <para> - This sets the compression method for a column. The supported compression - methods are <literal>pglz</literal> and <literal>lz4</literal>. - <literal>lz4</literal> is available only if <literal>--with-lz4</literal> - was used when building <productname>PostgreSQL</productname>. The default + The <literal>COMPRESSION</literal> clause sets the compression method + for a column. Compression is supported only for variable-width data + types, and is used only for columns whose storage type is main or + extended. (See <xref linkend="sql-altertable"/> for information on + column storage types.) Setting this property for a partitioned table + has no direct effect, because such tables have no storage of their own, + but the configured value is inherited by newly-created partitions. + The supported compression methods are <literal>pglz</literal> and + <literal>lz4</literal>. <literal>lz4</literal> is available only if + <literal>--with-lz4</literal> was used when building + <productname>PostgreSQL</productname>. The default is <literal>pglz</literal>. </para> </listitem> diff --git a/src/backend/access/common/detoast.c b/src/backend/access/common/detoast.c index b78d49167b..95d5b1c12a 100644 --- a/src/backend/access/common/detoast.c +++ b/src/backend/access/common/detoast.c @@ -477,8 +477,8 @@ toast_get_compression_oid(struct varlena *attr) return InvalidOid; /* - * Just fetch the toast compress header to know the compression method - * in the compressed data. + * Fetch just enough of the value to examine the compression header, + * so that we can find out the compression method. */ attr = toast_fetch_datum_slice(attr, 0, VARHDRSZ_COMPRESS); } @@ -503,7 +503,6 @@ toast_get_compression_handler(struct varlena *attr) cmid = TOAST_COMPRESS_METHOD(attr); - /* Get the handler routines for the compression method */ switch (cmid) { case PGLZ_COMPRESSION_ID: diff --git a/src/backend/access/compression/compress_lz4.c b/src/backend/access/compression/compress_lz4.c index 1856cf7df7..3079eff7eb 100644 --- a/src/backend/access/compression/compress_lz4.c +++ b/src/backend/access/compression/compress_lz4.c @@ -23,7 +23,7 @@ /* * lz4_cmcompress - compression routine for lz4 compression method * - * Compresses source into dest using the default strategy. Returns the + * Compresses source into dest using the LZ4 defaults. Returns the * compressed varlena, or NULL if compression fails. */ static struct varlena * @@ -42,8 +42,8 @@ lz4_cmcompress(const struct varlena *value) valsize = VARSIZE_ANY_EXHDR(value); /* - * Get maximum size of the compressed data that lz4 compression may output - * and allocate the memory for holding the compressed data and the header. + * 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_COMPRESS); @@ -83,10 +83,10 @@ lz4_cmdecompress(const struct varlena *value) int32 rawsize; struct varlena *result; - /* allocate memory for holding the uncompressed data */ + /* allocate memory for the uncompressed data */ result = (struct varlena *) palloc(VARRAWSIZE_4B_C(value) + VARHDRSZ); - /* decompress data using lz4 routine */ + /* decompress the data */ rawsize = LZ4_decompress_safe((char *) value + VARHDRSZ_COMPRESS, VARDATA(result), VARSIZE(value) - VARHDRSZ_COMPRESS, diff --git a/src/backend/executor/nodeModifyTable.c b/src/backend/executor/nodeModifyTable.c index f77deee399..920d9dd0d5 100644 --- a/src/backend/executor/nodeModifyTable.c +++ b/src/backend/executor/nodeModifyTable.c @@ -2117,7 +2117,7 @@ CompareCompressionMethodAndDecompress(TupleTableSlot *slot, TupleTableSlot *newslot = *outslot; /* - * If the called has passed an invalid slot then create a new slot. + * If the caller has passed an invalid slot then create a new slot. * Otherwise, just clear the existing tuple from the slot. This slot * should be stored by the caller so that it can be reused for * decompressing the subsequent tuples. diff --git a/src/include/nodes/execnodes.h b/src/include/nodes/execnodes.h index 18e8ecfd90..d8483c36b3 100644 --- a/src/include/nodes/execnodes.h +++ b/src/include/nodes/execnodes.h @@ -1183,8 +1183,8 @@ typedef struct ModifyTableState TupleTableSlot *mt_root_tuple_slot; /* - * Slot for storing the modified tuple, incase the target attribute's - * compression method doesn't match with the source table. + * Slot for storing the modified tuple, in case the target attribute's + * compression method doesn't match that of the source table. */ TupleTableSlot *mt_decompress_tuple_slot; -- 2.17.0 --YZ5djTAD1cGYuMQK Content-Type: text/x-diff; charset=us-ascii Content-Disposition: attachment; filename="v24-0006-alter-table-set-compression.patch" ^ permalink raw reply [nested|flat] 51+ messages in thread
* [PATCH v24 05/10] fixups.patch @ 2021-02-10 21:56 Robert Haas <[email protected]> 0 siblings, 0 replies; 51+ messages in thread From: Robert Haas @ 2021-02-10 21:56 UTC (permalink / raw) --- doc/src/sgml/ddl.sgml | 3 --- doc/src/sgml/ref/create_table.sgml | 15 +++++++++++---- src/backend/access/common/detoast.c | 5 ++--- src/backend/access/compression/compress_lz4.c | 10 +++++----- src/backend/executor/nodeModifyTable.c | 2 +- src/include/nodes/execnodes.h | 4 ++-- 6 files changed, 21 insertions(+), 18 deletions(-) diff --git a/doc/src/sgml/ddl.sgml b/doc/src/sgml/ddl.sgml index 4d7ed698b9..1e9a4625cc 100644 --- a/doc/src/sgml/ddl.sgml +++ b/doc/src/sgml/ddl.sgml @@ -3762,9 +3762,6 @@ CREATE TABLE measurement ( <productname>PostgreSQL</productname> tables (or, possibly, foreign tables). It is possible to specify a tablespace and storage parameters for each partition separately. - By default, each column in a partition inherits the compression method - from parent table's column, however a different compression method can be - set for each partition. </para> <para> diff --git a/doc/src/sgml/ref/create_table.sgml b/doc/src/sgml/ref/create_table.sgml index 51a7a977a5..a4b297340f 100644 --- a/doc/src/sgml/ref/create_table.sgml +++ b/doc/src/sgml/ref/create_table.sgml @@ -997,10 +997,17 @@ WITH ( MODULUS <replaceable class="parameter">numeric_literal</replaceable>, REM <term><literal>COMPRESSION <replaceable class="parameter">compression_method</replaceable></literal></term> <listitem> <para> - This sets the compression method for a column. The supported compression - methods are <literal>pglz</literal> and <literal>lz4</literal>. - <literal>lz4</literal> is available only if <literal>--with-lz4</literal> - was used when building <productname>PostgreSQL</productname>. The default + The <literal>COMPRESSION</literal> clause sets the compression method + for a column. Compression is supported only for variable-width data + types, and is used only for columns whose storage type is main or + extended. (See <xref linkend="sql-altertable"/> for information on + column storage types.) Setting this property for a partitioned table + has no direct effect, because such tables have no storage of their own, + but the configured value is inherited by newly-created partitions. + The supported compression methods are <literal>pglz</literal> and + <literal>lz4</literal>. <literal>lz4</literal> is available only if + <literal>--with-lz4</literal> was used when building + <productname>PostgreSQL</productname>. The default is <literal>pglz</literal>. </para> </listitem> diff --git a/src/backend/access/common/detoast.c b/src/backend/access/common/detoast.c index b78d49167b..95d5b1c12a 100644 --- a/src/backend/access/common/detoast.c +++ b/src/backend/access/common/detoast.c @@ -477,8 +477,8 @@ toast_get_compression_oid(struct varlena *attr) return InvalidOid; /* - * Just fetch the toast compress header to know the compression method - * in the compressed data. + * Fetch just enough of the value to examine the compression header, + * so that we can find out the compression method. */ attr = toast_fetch_datum_slice(attr, 0, VARHDRSZ_COMPRESS); } @@ -503,7 +503,6 @@ toast_get_compression_handler(struct varlena *attr) cmid = TOAST_COMPRESS_METHOD(attr); - /* Get the handler routines for the compression method */ switch (cmid) { case PGLZ_COMPRESSION_ID: diff --git a/src/backend/access/compression/compress_lz4.c b/src/backend/access/compression/compress_lz4.c index 1856cf7df7..3079eff7eb 100644 --- a/src/backend/access/compression/compress_lz4.c +++ b/src/backend/access/compression/compress_lz4.c @@ -23,7 +23,7 @@ /* * lz4_cmcompress - compression routine for lz4 compression method * - * Compresses source into dest using the default strategy. Returns the + * Compresses source into dest using the LZ4 defaults. Returns the * compressed varlena, or NULL if compression fails. */ static struct varlena * @@ -42,8 +42,8 @@ lz4_cmcompress(const struct varlena *value) valsize = VARSIZE_ANY_EXHDR(value); /* - * Get maximum size of the compressed data that lz4 compression may output - * and allocate the memory for holding the compressed data and the header. + * 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_COMPRESS); @@ -83,10 +83,10 @@ lz4_cmdecompress(const struct varlena *value) int32 rawsize; struct varlena *result; - /* allocate memory for holding the uncompressed data */ + /* allocate memory for the uncompressed data */ result = (struct varlena *) palloc(VARRAWSIZE_4B_C(value) + VARHDRSZ); - /* decompress data using lz4 routine */ + /* decompress the data */ rawsize = LZ4_decompress_safe((char *) value + VARHDRSZ_COMPRESS, VARDATA(result), VARSIZE(value) - VARHDRSZ_COMPRESS, diff --git a/src/backend/executor/nodeModifyTable.c b/src/backend/executor/nodeModifyTable.c index f77deee399..920d9dd0d5 100644 --- a/src/backend/executor/nodeModifyTable.c +++ b/src/backend/executor/nodeModifyTable.c @@ -2117,7 +2117,7 @@ CompareCompressionMethodAndDecompress(TupleTableSlot *slot, TupleTableSlot *newslot = *outslot; /* - * If the called has passed an invalid slot then create a new slot. + * If the caller has passed an invalid slot then create a new slot. * Otherwise, just clear the existing tuple from the slot. This slot * should be stored by the caller so that it can be reused for * decompressing the subsequent tuples. diff --git a/src/include/nodes/execnodes.h b/src/include/nodes/execnodes.h index 18e8ecfd90..d8483c36b3 100644 --- a/src/include/nodes/execnodes.h +++ b/src/include/nodes/execnodes.h @@ -1183,8 +1183,8 @@ typedef struct ModifyTableState TupleTableSlot *mt_root_tuple_slot; /* - * Slot for storing the modified tuple, incase the target attribute's - * compression method doesn't match with the source table. + * Slot for storing the modified tuple, in case the target attribute's + * compression method doesn't match that of the source table. */ TupleTableSlot *mt_decompress_tuple_slot; -- 2.17.0 --m51xatjYGsM+13rf Content-Type: text/x-diff; charset=us-ascii Content-Disposition: attachment; filename="v24-0006-alter-table-set-compression.patch" ^ permalink raw reply [nested|flat] 51+ messages in thread
* [PATCH v24 5/7] fixups.patch @ 2021-02-10 21:56 Robert Haas <[email protected]> 0 siblings, 0 replies; 51+ messages in thread From: Robert Haas @ 2021-02-10 21:56 UTC (permalink / raw) --- doc/src/sgml/ddl.sgml | 3 --- doc/src/sgml/ref/create_table.sgml | 15 +++++++++++---- src/backend/access/common/detoast.c | 5 ++--- src/backend/access/compression/compress_lz4.c | 10 +++++----- src/backend/executor/nodeModifyTable.c | 2 +- src/include/nodes/execnodes.h | 4 ++-- 6 files changed, 21 insertions(+), 18 deletions(-) diff --git a/doc/src/sgml/ddl.sgml b/doc/src/sgml/ddl.sgml index 4d7ed698b9..1e9a4625cc 100644 --- a/doc/src/sgml/ddl.sgml +++ b/doc/src/sgml/ddl.sgml @@ -3762,9 +3762,6 @@ CREATE TABLE measurement ( <productname>PostgreSQL</productname> tables (or, possibly, foreign tables). It is possible to specify a tablespace and storage parameters for each partition separately. - By default, each column in a partition inherits the compression method - from parent table's column, however a different compression method can be - set for each partition. </para> <para> diff --git a/doc/src/sgml/ref/create_table.sgml b/doc/src/sgml/ref/create_table.sgml index 51a7a977a5..a4b297340f 100644 --- a/doc/src/sgml/ref/create_table.sgml +++ b/doc/src/sgml/ref/create_table.sgml @@ -997,10 +997,17 @@ WITH ( MODULUS <replaceable class="parameter">numeric_literal</replaceable>, REM <term><literal>COMPRESSION <replaceable class="parameter">compression_method</replaceable></literal></term> <listitem> <para> - This sets the compression method for a column. The supported compression - methods are <literal>pglz</literal> and <literal>lz4</literal>. - <literal>lz4</literal> is available only if <literal>--with-lz4</literal> - was used when building <productname>PostgreSQL</productname>. The default + The <literal>COMPRESSION</literal> clause sets the compression method + for a column. Compression is supported only for variable-width data + types, and is used only for columns whose storage type is main or + extended. (See <xref linkend="sql-altertable"/> for information on + column storage types.) Setting this property for a partitioned table + has no direct effect, because such tables have no storage of their own, + but the configured value is inherited by newly-created partitions. + The supported compression methods are <literal>pglz</literal> and + <literal>lz4</literal>. <literal>lz4</literal> is available only if + <literal>--with-lz4</literal> was used when building + <productname>PostgreSQL</productname>. The default is <literal>pglz</literal>. </para> </listitem> diff --git a/src/backend/access/common/detoast.c b/src/backend/access/common/detoast.c index b78d49167b..95d5b1c12a 100644 --- a/src/backend/access/common/detoast.c +++ b/src/backend/access/common/detoast.c @@ -477,8 +477,8 @@ toast_get_compression_oid(struct varlena *attr) return InvalidOid; /* - * Just fetch the toast compress header to know the compression method - * in the compressed data. + * Fetch just enough of the value to examine the compression header, + * so that we can find out the compression method. */ attr = toast_fetch_datum_slice(attr, 0, VARHDRSZ_COMPRESS); } @@ -503,7 +503,6 @@ toast_get_compression_handler(struct varlena *attr) cmid = TOAST_COMPRESS_METHOD(attr); - /* Get the handler routines for the compression method */ switch (cmid) { case PGLZ_COMPRESSION_ID: diff --git a/src/backend/access/compression/compress_lz4.c b/src/backend/access/compression/compress_lz4.c index 1856cf7df7..3079eff7eb 100644 --- a/src/backend/access/compression/compress_lz4.c +++ b/src/backend/access/compression/compress_lz4.c @@ -23,7 +23,7 @@ /* * lz4_cmcompress - compression routine for lz4 compression method * - * Compresses source into dest using the default strategy. Returns the + * Compresses source into dest using the LZ4 defaults. Returns the * compressed varlena, or NULL if compression fails. */ static struct varlena * @@ -42,8 +42,8 @@ lz4_cmcompress(const struct varlena *value) valsize = VARSIZE_ANY_EXHDR(value); /* - * Get maximum size of the compressed data that lz4 compression may output - * and allocate the memory for holding the compressed data and the header. + * 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_COMPRESS); @@ -83,10 +83,10 @@ lz4_cmdecompress(const struct varlena *value) int32 rawsize; struct varlena *result; - /* allocate memory for holding the uncompressed data */ + /* allocate memory for the uncompressed data */ result = (struct varlena *) palloc(VARRAWSIZE_4B_C(value) + VARHDRSZ); - /* decompress data using lz4 routine */ + /* decompress the data */ rawsize = LZ4_decompress_safe((char *) value + VARHDRSZ_COMPRESS, VARDATA(result), VARSIZE(value) - VARHDRSZ_COMPRESS, diff --git a/src/backend/executor/nodeModifyTable.c b/src/backend/executor/nodeModifyTable.c index f77deee399..920d9dd0d5 100644 --- a/src/backend/executor/nodeModifyTable.c +++ b/src/backend/executor/nodeModifyTable.c @@ -2117,7 +2117,7 @@ CompareCompressionMethodAndDecompress(TupleTableSlot *slot, TupleTableSlot *newslot = *outslot; /* - * If the called has passed an invalid slot then create a new slot. + * If the caller has passed an invalid slot then create a new slot. * Otherwise, just clear the existing tuple from the slot. This slot * should be stored by the caller so that it can be reused for * decompressing the subsequent tuples. diff --git a/src/include/nodes/execnodes.h b/src/include/nodes/execnodes.h index 18e8ecfd90..d8483c36b3 100644 --- a/src/include/nodes/execnodes.h +++ b/src/include/nodes/execnodes.h @@ -1183,8 +1183,8 @@ typedef struct ModifyTableState TupleTableSlot *mt_root_tuple_slot; /* - * Slot for storing the modified tuple, incase the target attribute's - * compression method doesn't match with the source table. + * Slot for storing the modified tuple, in case the target attribute's + * compression method doesn't match that of the source table. */ TupleTableSlot *mt_decompress_tuple_slot; -- 2.17.0 --YZ5djTAD1cGYuMQK Content-Type: text/x-diff; charset=us-ascii Content-Disposition: attachment; filename="v24-0006-alter-table-set-compression.patch" ^ permalink raw reply [nested|flat] 51+ messages in thread
* [PATCH v24 05/10] fixups.patch @ 2021-02-10 21:56 Robert Haas <[email protected]> 0 siblings, 0 replies; 51+ messages in thread From: Robert Haas @ 2021-02-10 21:56 UTC (permalink / raw) --- doc/src/sgml/ddl.sgml | 3 --- doc/src/sgml/ref/create_table.sgml | 15 +++++++++++---- src/backend/access/common/detoast.c | 5 ++--- src/backend/access/compression/compress_lz4.c | 10 +++++----- src/backend/executor/nodeModifyTable.c | 2 +- src/include/nodes/execnodes.h | 4 ++-- 6 files changed, 21 insertions(+), 18 deletions(-) diff --git a/doc/src/sgml/ddl.sgml b/doc/src/sgml/ddl.sgml index 4d7ed698b9..1e9a4625cc 100644 --- a/doc/src/sgml/ddl.sgml +++ b/doc/src/sgml/ddl.sgml @@ -3762,9 +3762,6 @@ CREATE TABLE measurement ( <productname>PostgreSQL</productname> tables (or, possibly, foreign tables). It is possible to specify a tablespace and storage parameters for each partition separately. - By default, each column in a partition inherits the compression method - from parent table's column, however a different compression method can be - set for each partition. </para> <para> diff --git a/doc/src/sgml/ref/create_table.sgml b/doc/src/sgml/ref/create_table.sgml index 51a7a977a5..a4b297340f 100644 --- a/doc/src/sgml/ref/create_table.sgml +++ b/doc/src/sgml/ref/create_table.sgml @@ -997,10 +997,17 @@ WITH ( MODULUS <replaceable class="parameter">numeric_literal</replaceable>, REM <term><literal>COMPRESSION <replaceable class="parameter">compression_method</replaceable></literal></term> <listitem> <para> - This sets the compression method for a column. The supported compression - methods are <literal>pglz</literal> and <literal>lz4</literal>. - <literal>lz4</literal> is available only if <literal>--with-lz4</literal> - was used when building <productname>PostgreSQL</productname>. The default + The <literal>COMPRESSION</literal> clause sets the compression method + for a column. Compression is supported only for variable-width data + types, and is used only for columns whose storage type is main or + extended. (See <xref linkend="sql-altertable"/> for information on + column storage types.) Setting this property for a partitioned table + has no direct effect, because such tables have no storage of their own, + but the configured value is inherited by newly-created partitions. + The supported compression methods are <literal>pglz</literal> and + <literal>lz4</literal>. <literal>lz4</literal> is available only if + <literal>--with-lz4</literal> was used when building + <productname>PostgreSQL</productname>. The default is <literal>pglz</literal>. </para> </listitem> diff --git a/src/backend/access/common/detoast.c b/src/backend/access/common/detoast.c index b78d49167b..95d5b1c12a 100644 --- a/src/backend/access/common/detoast.c +++ b/src/backend/access/common/detoast.c @@ -477,8 +477,8 @@ toast_get_compression_oid(struct varlena *attr) return InvalidOid; /* - * Just fetch the toast compress header to know the compression method - * in the compressed data. + * Fetch just enough of the value to examine the compression header, + * so that we can find out the compression method. */ attr = toast_fetch_datum_slice(attr, 0, VARHDRSZ_COMPRESS); } @@ -503,7 +503,6 @@ toast_get_compression_handler(struct varlena *attr) cmid = TOAST_COMPRESS_METHOD(attr); - /* Get the handler routines for the compression method */ switch (cmid) { case PGLZ_COMPRESSION_ID: diff --git a/src/backend/access/compression/compress_lz4.c b/src/backend/access/compression/compress_lz4.c index 1856cf7df7..3079eff7eb 100644 --- a/src/backend/access/compression/compress_lz4.c +++ b/src/backend/access/compression/compress_lz4.c @@ -23,7 +23,7 @@ /* * lz4_cmcompress - compression routine for lz4 compression method * - * Compresses source into dest using the default strategy. Returns the + * Compresses source into dest using the LZ4 defaults. Returns the * compressed varlena, or NULL if compression fails. */ static struct varlena * @@ -42,8 +42,8 @@ lz4_cmcompress(const struct varlena *value) valsize = VARSIZE_ANY_EXHDR(value); /* - * Get maximum size of the compressed data that lz4 compression may output - * and allocate the memory for holding the compressed data and the header. + * 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_COMPRESS); @@ -83,10 +83,10 @@ lz4_cmdecompress(const struct varlena *value) int32 rawsize; struct varlena *result; - /* allocate memory for holding the uncompressed data */ + /* allocate memory for the uncompressed data */ result = (struct varlena *) palloc(VARRAWSIZE_4B_C(value) + VARHDRSZ); - /* decompress data using lz4 routine */ + /* decompress the data */ rawsize = LZ4_decompress_safe((char *) value + VARHDRSZ_COMPRESS, VARDATA(result), VARSIZE(value) - VARHDRSZ_COMPRESS, diff --git a/src/backend/executor/nodeModifyTable.c b/src/backend/executor/nodeModifyTable.c index f77deee399..920d9dd0d5 100644 --- a/src/backend/executor/nodeModifyTable.c +++ b/src/backend/executor/nodeModifyTable.c @@ -2117,7 +2117,7 @@ CompareCompressionMethodAndDecompress(TupleTableSlot *slot, TupleTableSlot *newslot = *outslot; /* - * If the called has passed an invalid slot then create a new slot. + * If the caller has passed an invalid slot then create a new slot. * Otherwise, just clear the existing tuple from the slot. This slot * should be stored by the caller so that it can be reused for * decompressing the subsequent tuples. diff --git a/src/include/nodes/execnodes.h b/src/include/nodes/execnodes.h index 18e8ecfd90..d8483c36b3 100644 --- a/src/include/nodes/execnodes.h +++ b/src/include/nodes/execnodes.h @@ -1183,8 +1183,8 @@ typedef struct ModifyTableState TupleTableSlot *mt_root_tuple_slot; /* - * Slot for storing the modified tuple, incase the target attribute's - * compression method doesn't match with the source table. + * Slot for storing the modified tuple, in case the target attribute's + * compression method doesn't match that of the source table. */ TupleTableSlot *mt_decompress_tuple_slot; -- 2.17.0 --m51xatjYGsM+13rf Content-Type: text/x-diff; charset=us-ascii Content-Disposition: attachment; filename="v24-0006-alter-table-set-compression.patch" ^ permalink raw reply [nested|flat] 51+ messages in thread
* [PATCH v24 5/7] fixups.patch @ 2021-02-10 21:56 Robert Haas <[email protected]> 0 siblings, 0 replies; 51+ messages in thread From: Robert Haas @ 2021-02-10 21:56 UTC (permalink / raw) --- doc/src/sgml/ddl.sgml | 3 --- doc/src/sgml/ref/create_table.sgml | 15 +++++++++++---- src/backend/access/common/detoast.c | 5 ++--- src/backend/access/compression/compress_lz4.c | 10 +++++----- src/backend/executor/nodeModifyTable.c | 2 +- src/include/nodes/execnodes.h | 4 ++-- 6 files changed, 21 insertions(+), 18 deletions(-) diff --git a/doc/src/sgml/ddl.sgml b/doc/src/sgml/ddl.sgml index 4d7ed698b9..1e9a4625cc 100644 --- a/doc/src/sgml/ddl.sgml +++ b/doc/src/sgml/ddl.sgml @@ -3762,9 +3762,6 @@ CREATE TABLE measurement ( <productname>PostgreSQL</productname> tables (or, possibly, foreign tables). It is possible to specify a tablespace and storage parameters for each partition separately. - By default, each column in a partition inherits the compression method - from parent table's column, however a different compression method can be - set for each partition. </para> <para> diff --git a/doc/src/sgml/ref/create_table.sgml b/doc/src/sgml/ref/create_table.sgml index 51a7a977a5..a4b297340f 100644 --- a/doc/src/sgml/ref/create_table.sgml +++ b/doc/src/sgml/ref/create_table.sgml @@ -997,10 +997,17 @@ WITH ( MODULUS <replaceable class="parameter">numeric_literal</replaceable>, REM <term><literal>COMPRESSION <replaceable class="parameter">compression_method</replaceable></literal></term> <listitem> <para> - This sets the compression method for a column. The supported compression - methods are <literal>pglz</literal> and <literal>lz4</literal>. - <literal>lz4</literal> is available only if <literal>--with-lz4</literal> - was used when building <productname>PostgreSQL</productname>. The default + The <literal>COMPRESSION</literal> clause sets the compression method + for a column. Compression is supported only for variable-width data + types, and is used only for columns whose storage type is main or + extended. (See <xref linkend="sql-altertable"/> for information on + column storage types.) Setting this property for a partitioned table + has no direct effect, because such tables have no storage of their own, + but the configured value is inherited by newly-created partitions. + The supported compression methods are <literal>pglz</literal> and + <literal>lz4</literal>. <literal>lz4</literal> is available only if + <literal>--with-lz4</literal> was used when building + <productname>PostgreSQL</productname>. The default is <literal>pglz</literal>. </para> </listitem> diff --git a/src/backend/access/common/detoast.c b/src/backend/access/common/detoast.c index b78d49167b..95d5b1c12a 100644 --- a/src/backend/access/common/detoast.c +++ b/src/backend/access/common/detoast.c @@ -477,8 +477,8 @@ toast_get_compression_oid(struct varlena *attr) return InvalidOid; /* - * Just fetch the toast compress header to know the compression method - * in the compressed data. + * Fetch just enough of the value to examine the compression header, + * so that we can find out the compression method. */ attr = toast_fetch_datum_slice(attr, 0, VARHDRSZ_COMPRESS); } @@ -503,7 +503,6 @@ toast_get_compression_handler(struct varlena *attr) cmid = TOAST_COMPRESS_METHOD(attr); - /* Get the handler routines for the compression method */ switch (cmid) { case PGLZ_COMPRESSION_ID: diff --git a/src/backend/access/compression/compress_lz4.c b/src/backend/access/compression/compress_lz4.c index 1856cf7df7..3079eff7eb 100644 --- a/src/backend/access/compression/compress_lz4.c +++ b/src/backend/access/compression/compress_lz4.c @@ -23,7 +23,7 @@ /* * lz4_cmcompress - compression routine for lz4 compression method * - * Compresses source into dest using the default strategy. Returns the + * Compresses source into dest using the LZ4 defaults. Returns the * compressed varlena, or NULL if compression fails. */ static struct varlena * @@ -42,8 +42,8 @@ lz4_cmcompress(const struct varlena *value) valsize = VARSIZE_ANY_EXHDR(value); /* - * Get maximum size of the compressed data that lz4 compression may output - * and allocate the memory for holding the compressed data and the header. + * 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_COMPRESS); @@ -83,10 +83,10 @@ lz4_cmdecompress(const struct varlena *value) int32 rawsize; struct varlena *result; - /* allocate memory for holding the uncompressed data */ + /* allocate memory for the uncompressed data */ result = (struct varlena *) palloc(VARRAWSIZE_4B_C(value) + VARHDRSZ); - /* decompress data using lz4 routine */ + /* decompress the data */ rawsize = LZ4_decompress_safe((char *) value + VARHDRSZ_COMPRESS, VARDATA(result), VARSIZE(value) - VARHDRSZ_COMPRESS, diff --git a/src/backend/executor/nodeModifyTable.c b/src/backend/executor/nodeModifyTable.c index f77deee399..920d9dd0d5 100644 --- a/src/backend/executor/nodeModifyTable.c +++ b/src/backend/executor/nodeModifyTable.c @@ -2117,7 +2117,7 @@ CompareCompressionMethodAndDecompress(TupleTableSlot *slot, TupleTableSlot *newslot = *outslot; /* - * If the called has passed an invalid slot then create a new slot. + * If the caller has passed an invalid slot then create a new slot. * Otherwise, just clear the existing tuple from the slot. This slot * should be stored by the caller so that it can be reused for * decompressing the subsequent tuples. diff --git a/src/include/nodes/execnodes.h b/src/include/nodes/execnodes.h index 18e8ecfd90..d8483c36b3 100644 --- a/src/include/nodes/execnodes.h +++ b/src/include/nodes/execnodes.h @@ -1183,8 +1183,8 @@ typedef struct ModifyTableState TupleTableSlot *mt_root_tuple_slot; /* - * Slot for storing the modified tuple, incase the target attribute's - * compression method doesn't match with the source table. + * Slot for storing the modified tuple, in case the target attribute's + * compression method doesn't match that of the source table. */ TupleTableSlot *mt_decompress_tuple_slot; -- 2.17.0 --YZ5djTAD1cGYuMQK Content-Type: text/x-diff; charset=us-ascii Content-Disposition: attachment; filename="v24-0006-alter-table-set-compression.patch" ^ permalink raw reply [nested|flat] 51+ messages in thread
* [PATCH v24 05/10] fixups.patch @ 2021-02-10 21:56 Robert Haas <[email protected]> 0 siblings, 0 replies; 51+ messages in thread From: Robert Haas @ 2021-02-10 21:56 UTC (permalink / raw) --- doc/src/sgml/ddl.sgml | 3 --- doc/src/sgml/ref/create_table.sgml | 15 +++++++++++---- src/backend/access/common/detoast.c | 5 ++--- src/backend/access/compression/compress_lz4.c | 10 +++++----- src/backend/executor/nodeModifyTable.c | 2 +- src/include/nodes/execnodes.h | 4 ++-- 6 files changed, 21 insertions(+), 18 deletions(-) diff --git a/doc/src/sgml/ddl.sgml b/doc/src/sgml/ddl.sgml index 4d7ed698b9..1e9a4625cc 100644 --- a/doc/src/sgml/ddl.sgml +++ b/doc/src/sgml/ddl.sgml @@ -3762,9 +3762,6 @@ CREATE TABLE measurement ( <productname>PostgreSQL</productname> tables (or, possibly, foreign tables). It is possible to specify a tablespace and storage parameters for each partition separately. - By default, each column in a partition inherits the compression method - from parent table's column, however a different compression method can be - set for each partition. </para> <para> diff --git a/doc/src/sgml/ref/create_table.sgml b/doc/src/sgml/ref/create_table.sgml index 51a7a977a5..a4b297340f 100644 --- a/doc/src/sgml/ref/create_table.sgml +++ b/doc/src/sgml/ref/create_table.sgml @@ -997,10 +997,17 @@ WITH ( MODULUS <replaceable class="parameter">numeric_literal</replaceable>, REM <term><literal>COMPRESSION <replaceable class="parameter">compression_method</replaceable></literal></term> <listitem> <para> - This sets the compression method for a column. The supported compression - methods are <literal>pglz</literal> and <literal>lz4</literal>. - <literal>lz4</literal> is available only if <literal>--with-lz4</literal> - was used when building <productname>PostgreSQL</productname>. The default + The <literal>COMPRESSION</literal> clause sets the compression method + for a column. Compression is supported only for variable-width data + types, and is used only for columns whose storage type is main or + extended. (See <xref linkend="sql-altertable"/> for information on + column storage types.) Setting this property for a partitioned table + has no direct effect, because such tables have no storage of their own, + but the configured value is inherited by newly-created partitions. + The supported compression methods are <literal>pglz</literal> and + <literal>lz4</literal>. <literal>lz4</literal> is available only if + <literal>--with-lz4</literal> was used when building + <productname>PostgreSQL</productname>. The default is <literal>pglz</literal>. </para> </listitem> diff --git a/src/backend/access/common/detoast.c b/src/backend/access/common/detoast.c index b78d49167b..95d5b1c12a 100644 --- a/src/backend/access/common/detoast.c +++ b/src/backend/access/common/detoast.c @@ -477,8 +477,8 @@ toast_get_compression_oid(struct varlena *attr) return InvalidOid; /* - * Just fetch the toast compress header to know the compression method - * in the compressed data. + * Fetch just enough of the value to examine the compression header, + * so that we can find out the compression method. */ attr = toast_fetch_datum_slice(attr, 0, VARHDRSZ_COMPRESS); } @@ -503,7 +503,6 @@ toast_get_compression_handler(struct varlena *attr) cmid = TOAST_COMPRESS_METHOD(attr); - /* Get the handler routines for the compression method */ switch (cmid) { case PGLZ_COMPRESSION_ID: diff --git a/src/backend/access/compression/compress_lz4.c b/src/backend/access/compression/compress_lz4.c index 1856cf7df7..3079eff7eb 100644 --- a/src/backend/access/compression/compress_lz4.c +++ b/src/backend/access/compression/compress_lz4.c @@ -23,7 +23,7 @@ /* * lz4_cmcompress - compression routine for lz4 compression method * - * Compresses source into dest using the default strategy. Returns the + * Compresses source into dest using the LZ4 defaults. Returns the * compressed varlena, or NULL if compression fails. */ static struct varlena * @@ -42,8 +42,8 @@ lz4_cmcompress(const struct varlena *value) valsize = VARSIZE_ANY_EXHDR(value); /* - * Get maximum size of the compressed data that lz4 compression may output - * and allocate the memory for holding the compressed data and the header. + * 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_COMPRESS); @@ -83,10 +83,10 @@ lz4_cmdecompress(const struct varlena *value) int32 rawsize; struct varlena *result; - /* allocate memory for holding the uncompressed data */ + /* allocate memory for the uncompressed data */ result = (struct varlena *) palloc(VARRAWSIZE_4B_C(value) + VARHDRSZ); - /* decompress data using lz4 routine */ + /* decompress the data */ rawsize = LZ4_decompress_safe((char *) value + VARHDRSZ_COMPRESS, VARDATA(result), VARSIZE(value) - VARHDRSZ_COMPRESS, diff --git a/src/backend/executor/nodeModifyTable.c b/src/backend/executor/nodeModifyTable.c index f77deee399..920d9dd0d5 100644 --- a/src/backend/executor/nodeModifyTable.c +++ b/src/backend/executor/nodeModifyTable.c @@ -2117,7 +2117,7 @@ CompareCompressionMethodAndDecompress(TupleTableSlot *slot, TupleTableSlot *newslot = *outslot; /* - * If the called has passed an invalid slot then create a new slot. + * If the caller has passed an invalid slot then create a new slot. * Otherwise, just clear the existing tuple from the slot. This slot * should be stored by the caller so that it can be reused for * decompressing the subsequent tuples. diff --git a/src/include/nodes/execnodes.h b/src/include/nodes/execnodes.h index 18e8ecfd90..d8483c36b3 100644 --- a/src/include/nodes/execnodes.h +++ b/src/include/nodes/execnodes.h @@ -1183,8 +1183,8 @@ typedef struct ModifyTableState TupleTableSlot *mt_root_tuple_slot; /* - * Slot for storing the modified tuple, incase the target attribute's - * compression method doesn't match with the source table. + * Slot for storing the modified tuple, in case the target attribute's + * compression method doesn't match that of the source table. */ TupleTableSlot *mt_decompress_tuple_slot; -- 2.17.0 --m51xatjYGsM+13rf Content-Type: text/x-diff; charset=us-ascii Content-Disposition: attachment; filename="v24-0006-alter-table-set-compression.patch" ^ permalink raw reply [nested|flat] 51+ messages in thread
* [PATCH v24 5/7] fixups.patch @ 2021-02-10 21:56 Robert Haas <[email protected]> 0 siblings, 0 replies; 51+ messages in thread From: Robert Haas @ 2021-02-10 21:56 UTC (permalink / raw) --- doc/src/sgml/ddl.sgml | 3 --- doc/src/sgml/ref/create_table.sgml | 15 +++++++++++---- src/backend/access/common/detoast.c | 5 ++--- src/backend/access/compression/compress_lz4.c | 10 +++++----- src/backend/executor/nodeModifyTable.c | 2 +- src/include/nodes/execnodes.h | 4 ++-- 6 files changed, 21 insertions(+), 18 deletions(-) diff --git a/doc/src/sgml/ddl.sgml b/doc/src/sgml/ddl.sgml index 4d7ed698b9..1e9a4625cc 100644 --- a/doc/src/sgml/ddl.sgml +++ b/doc/src/sgml/ddl.sgml @@ -3762,9 +3762,6 @@ CREATE TABLE measurement ( <productname>PostgreSQL</productname> tables (or, possibly, foreign tables). It is possible to specify a tablespace and storage parameters for each partition separately. - By default, each column in a partition inherits the compression method - from parent table's column, however a different compression method can be - set for each partition. </para> <para> diff --git a/doc/src/sgml/ref/create_table.sgml b/doc/src/sgml/ref/create_table.sgml index 51a7a977a5..a4b297340f 100644 --- a/doc/src/sgml/ref/create_table.sgml +++ b/doc/src/sgml/ref/create_table.sgml @@ -997,10 +997,17 @@ WITH ( MODULUS <replaceable class="parameter">numeric_literal</replaceable>, REM <term><literal>COMPRESSION <replaceable class="parameter">compression_method</replaceable></literal></term> <listitem> <para> - This sets the compression method for a column. The supported compression - methods are <literal>pglz</literal> and <literal>lz4</literal>. - <literal>lz4</literal> is available only if <literal>--with-lz4</literal> - was used when building <productname>PostgreSQL</productname>. The default + The <literal>COMPRESSION</literal> clause sets the compression method + for a column. Compression is supported only for variable-width data + types, and is used only for columns whose storage type is main or + extended. (See <xref linkend="sql-altertable"/> for information on + column storage types.) Setting this property for a partitioned table + has no direct effect, because such tables have no storage of their own, + but the configured value is inherited by newly-created partitions. + The supported compression methods are <literal>pglz</literal> and + <literal>lz4</literal>. <literal>lz4</literal> is available only if + <literal>--with-lz4</literal> was used when building + <productname>PostgreSQL</productname>. The default is <literal>pglz</literal>. </para> </listitem> diff --git a/src/backend/access/common/detoast.c b/src/backend/access/common/detoast.c index b78d49167b..95d5b1c12a 100644 --- a/src/backend/access/common/detoast.c +++ b/src/backend/access/common/detoast.c @@ -477,8 +477,8 @@ toast_get_compression_oid(struct varlena *attr) return InvalidOid; /* - * Just fetch the toast compress header to know the compression method - * in the compressed data. + * Fetch just enough of the value to examine the compression header, + * so that we can find out the compression method. */ attr = toast_fetch_datum_slice(attr, 0, VARHDRSZ_COMPRESS); } @@ -503,7 +503,6 @@ toast_get_compression_handler(struct varlena *attr) cmid = TOAST_COMPRESS_METHOD(attr); - /* Get the handler routines for the compression method */ switch (cmid) { case PGLZ_COMPRESSION_ID: diff --git a/src/backend/access/compression/compress_lz4.c b/src/backend/access/compression/compress_lz4.c index 1856cf7df7..3079eff7eb 100644 --- a/src/backend/access/compression/compress_lz4.c +++ b/src/backend/access/compression/compress_lz4.c @@ -23,7 +23,7 @@ /* * lz4_cmcompress - compression routine for lz4 compression method * - * Compresses source into dest using the default strategy. Returns the + * Compresses source into dest using the LZ4 defaults. Returns the * compressed varlena, or NULL if compression fails. */ static struct varlena * @@ -42,8 +42,8 @@ lz4_cmcompress(const struct varlena *value) valsize = VARSIZE_ANY_EXHDR(value); /* - * Get maximum size of the compressed data that lz4 compression may output - * and allocate the memory for holding the compressed data and the header. + * 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_COMPRESS); @@ -83,10 +83,10 @@ lz4_cmdecompress(const struct varlena *value) int32 rawsize; struct varlena *result; - /* allocate memory for holding the uncompressed data */ + /* allocate memory for the uncompressed data */ result = (struct varlena *) palloc(VARRAWSIZE_4B_C(value) + VARHDRSZ); - /* decompress data using lz4 routine */ + /* decompress the data */ rawsize = LZ4_decompress_safe((char *) value + VARHDRSZ_COMPRESS, VARDATA(result), VARSIZE(value) - VARHDRSZ_COMPRESS, diff --git a/src/backend/executor/nodeModifyTable.c b/src/backend/executor/nodeModifyTable.c index f77deee399..920d9dd0d5 100644 --- a/src/backend/executor/nodeModifyTable.c +++ b/src/backend/executor/nodeModifyTable.c @@ -2117,7 +2117,7 @@ CompareCompressionMethodAndDecompress(TupleTableSlot *slot, TupleTableSlot *newslot = *outslot; /* - * If the called has passed an invalid slot then create a new slot. + * If the caller has passed an invalid slot then create a new slot. * Otherwise, just clear the existing tuple from the slot. This slot * should be stored by the caller so that it can be reused for * decompressing the subsequent tuples. diff --git a/src/include/nodes/execnodes.h b/src/include/nodes/execnodes.h index 18e8ecfd90..d8483c36b3 100644 --- a/src/include/nodes/execnodes.h +++ b/src/include/nodes/execnodes.h @@ -1183,8 +1183,8 @@ typedef struct ModifyTableState TupleTableSlot *mt_root_tuple_slot; /* - * Slot for storing the modified tuple, incase the target attribute's - * compression method doesn't match with the source table. + * Slot for storing the modified tuple, in case the target attribute's + * compression method doesn't match that of the source table. */ TupleTableSlot *mt_decompress_tuple_slot; -- 2.17.0 --YZ5djTAD1cGYuMQK Content-Type: text/x-diff; charset=us-ascii Content-Disposition: attachment; filename="v24-0006-alter-table-set-compression.patch" ^ permalink raw reply [nested|flat] 51+ messages in thread
* [PATCH v24 5/7] fixups.patch @ 2021-02-10 21:56 Robert Haas <[email protected]> 0 siblings, 0 replies; 51+ messages in thread From: Robert Haas @ 2021-02-10 21:56 UTC (permalink / raw) --- doc/src/sgml/ddl.sgml | 3 --- doc/src/sgml/ref/create_table.sgml | 15 +++++++++++---- src/backend/access/common/detoast.c | 5 ++--- src/backend/access/compression/compress_lz4.c | 10 +++++----- src/backend/executor/nodeModifyTable.c | 2 +- src/include/nodes/execnodes.h | 4 ++-- 6 files changed, 21 insertions(+), 18 deletions(-) diff --git a/doc/src/sgml/ddl.sgml b/doc/src/sgml/ddl.sgml index 4d7ed698b9..1e9a4625cc 100644 --- a/doc/src/sgml/ddl.sgml +++ b/doc/src/sgml/ddl.sgml @@ -3762,9 +3762,6 @@ CREATE TABLE measurement ( <productname>PostgreSQL</productname> tables (or, possibly, foreign tables). It is possible to specify a tablespace and storage parameters for each partition separately. - By default, each column in a partition inherits the compression method - from parent table's column, however a different compression method can be - set for each partition. </para> <para> diff --git a/doc/src/sgml/ref/create_table.sgml b/doc/src/sgml/ref/create_table.sgml index 51a7a977a5..a4b297340f 100644 --- a/doc/src/sgml/ref/create_table.sgml +++ b/doc/src/sgml/ref/create_table.sgml @@ -997,10 +997,17 @@ WITH ( MODULUS <replaceable class="parameter">numeric_literal</replaceable>, REM <term><literal>COMPRESSION <replaceable class="parameter">compression_method</replaceable></literal></term> <listitem> <para> - This sets the compression method for a column. The supported compression - methods are <literal>pglz</literal> and <literal>lz4</literal>. - <literal>lz4</literal> is available only if <literal>--with-lz4</literal> - was used when building <productname>PostgreSQL</productname>. The default + The <literal>COMPRESSION</literal> clause sets the compression method + for a column. Compression is supported only for variable-width data + types, and is used only for columns whose storage type is main or + extended. (See <xref linkend="sql-altertable"/> for information on + column storage types.) Setting this property for a partitioned table + has no direct effect, because such tables have no storage of their own, + but the configured value is inherited by newly-created partitions. + The supported compression methods are <literal>pglz</literal> and + <literal>lz4</literal>. <literal>lz4</literal> is available only if + <literal>--with-lz4</literal> was used when building + <productname>PostgreSQL</productname>. The default is <literal>pglz</literal>. </para> </listitem> diff --git a/src/backend/access/common/detoast.c b/src/backend/access/common/detoast.c index b78d49167b..95d5b1c12a 100644 --- a/src/backend/access/common/detoast.c +++ b/src/backend/access/common/detoast.c @@ -477,8 +477,8 @@ toast_get_compression_oid(struct varlena *attr) return InvalidOid; /* - * Just fetch the toast compress header to know the compression method - * in the compressed data. + * Fetch just enough of the value to examine the compression header, + * so that we can find out the compression method. */ attr = toast_fetch_datum_slice(attr, 0, VARHDRSZ_COMPRESS); } @@ -503,7 +503,6 @@ toast_get_compression_handler(struct varlena *attr) cmid = TOAST_COMPRESS_METHOD(attr); - /* Get the handler routines for the compression method */ switch (cmid) { case PGLZ_COMPRESSION_ID: diff --git a/src/backend/access/compression/compress_lz4.c b/src/backend/access/compression/compress_lz4.c index 1856cf7df7..3079eff7eb 100644 --- a/src/backend/access/compression/compress_lz4.c +++ b/src/backend/access/compression/compress_lz4.c @@ -23,7 +23,7 @@ /* * lz4_cmcompress - compression routine for lz4 compression method * - * Compresses source into dest using the default strategy. Returns the + * Compresses source into dest using the LZ4 defaults. Returns the * compressed varlena, or NULL if compression fails. */ static struct varlena * @@ -42,8 +42,8 @@ lz4_cmcompress(const struct varlena *value) valsize = VARSIZE_ANY_EXHDR(value); /* - * Get maximum size of the compressed data that lz4 compression may output - * and allocate the memory for holding the compressed data and the header. + * 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_COMPRESS); @@ -83,10 +83,10 @@ lz4_cmdecompress(const struct varlena *value) int32 rawsize; struct varlena *result; - /* allocate memory for holding the uncompressed data */ + /* allocate memory for the uncompressed data */ result = (struct varlena *) palloc(VARRAWSIZE_4B_C(value) + VARHDRSZ); - /* decompress data using lz4 routine */ + /* decompress the data */ rawsize = LZ4_decompress_safe((char *) value + VARHDRSZ_COMPRESS, VARDATA(result), VARSIZE(value) - VARHDRSZ_COMPRESS, diff --git a/src/backend/executor/nodeModifyTable.c b/src/backend/executor/nodeModifyTable.c index f77deee399..920d9dd0d5 100644 --- a/src/backend/executor/nodeModifyTable.c +++ b/src/backend/executor/nodeModifyTable.c @@ -2117,7 +2117,7 @@ CompareCompressionMethodAndDecompress(TupleTableSlot *slot, TupleTableSlot *newslot = *outslot; /* - * If the called has passed an invalid slot then create a new slot. + * If the caller has passed an invalid slot then create a new slot. * Otherwise, just clear the existing tuple from the slot. This slot * should be stored by the caller so that it can be reused for * decompressing the subsequent tuples. diff --git a/src/include/nodes/execnodes.h b/src/include/nodes/execnodes.h index 18e8ecfd90..d8483c36b3 100644 --- a/src/include/nodes/execnodes.h +++ b/src/include/nodes/execnodes.h @@ -1183,8 +1183,8 @@ typedef struct ModifyTableState TupleTableSlot *mt_root_tuple_slot; /* - * Slot for storing the modified tuple, incase the target attribute's - * compression method doesn't match with the source table. + * Slot for storing the modified tuple, in case the target attribute's + * compression method doesn't match that of the source table. */ TupleTableSlot *mt_decompress_tuple_slot; -- 2.17.0 --YZ5djTAD1cGYuMQK Content-Type: text/x-diff; charset=us-ascii Content-Disposition: attachment; filename="v24-0006-alter-table-set-compression.patch" ^ permalink raw reply [nested|flat] 51+ messages in thread
* [PATCH v24 05/10] fixups.patch @ 2021-02-10 21:56 Robert Haas <[email protected]> 0 siblings, 0 replies; 51+ messages in thread From: Robert Haas @ 2021-02-10 21:56 UTC (permalink / raw) --- doc/src/sgml/ddl.sgml | 3 --- doc/src/sgml/ref/create_table.sgml | 15 +++++++++++---- src/backend/access/common/detoast.c | 5 ++--- src/backend/access/compression/compress_lz4.c | 10 +++++----- src/backend/executor/nodeModifyTable.c | 2 +- src/include/nodes/execnodes.h | 4 ++-- 6 files changed, 21 insertions(+), 18 deletions(-) diff --git a/doc/src/sgml/ddl.sgml b/doc/src/sgml/ddl.sgml index 4d7ed698b9..1e9a4625cc 100644 --- a/doc/src/sgml/ddl.sgml +++ b/doc/src/sgml/ddl.sgml @@ -3762,9 +3762,6 @@ CREATE TABLE measurement ( <productname>PostgreSQL</productname> tables (or, possibly, foreign tables). It is possible to specify a tablespace and storage parameters for each partition separately. - By default, each column in a partition inherits the compression method - from parent table's column, however a different compression method can be - set for each partition. </para> <para> diff --git a/doc/src/sgml/ref/create_table.sgml b/doc/src/sgml/ref/create_table.sgml index 51a7a977a5..a4b297340f 100644 --- a/doc/src/sgml/ref/create_table.sgml +++ b/doc/src/sgml/ref/create_table.sgml @@ -997,10 +997,17 @@ WITH ( MODULUS <replaceable class="parameter">numeric_literal</replaceable>, REM <term><literal>COMPRESSION <replaceable class="parameter">compression_method</replaceable></literal></term> <listitem> <para> - This sets the compression method for a column. The supported compression - methods are <literal>pglz</literal> and <literal>lz4</literal>. - <literal>lz4</literal> is available only if <literal>--with-lz4</literal> - was used when building <productname>PostgreSQL</productname>. The default + The <literal>COMPRESSION</literal> clause sets the compression method + for a column. Compression is supported only for variable-width data + types, and is used only for columns whose storage type is main or + extended. (See <xref linkend="sql-altertable"/> for information on + column storage types.) Setting this property for a partitioned table + has no direct effect, because such tables have no storage of their own, + but the configured value is inherited by newly-created partitions. + The supported compression methods are <literal>pglz</literal> and + <literal>lz4</literal>. <literal>lz4</literal> is available only if + <literal>--with-lz4</literal> was used when building + <productname>PostgreSQL</productname>. The default is <literal>pglz</literal>. </para> </listitem> diff --git a/src/backend/access/common/detoast.c b/src/backend/access/common/detoast.c index b78d49167b..95d5b1c12a 100644 --- a/src/backend/access/common/detoast.c +++ b/src/backend/access/common/detoast.c @@ -477,8 +477,8 @@ toast_get_compression_oid(struct varlena *attr) return InvalidOid; /* - * Just fetch the toast compress header to know the compression method - * in the compressed data. + * Fetch just enough of the value to examine the compression header, + * so that we can find out the compression method. */ attr = toast_fetch_datum_slice(attr, 0, VARHDRSZ_COMPRESS); } @@ -503,7 +503,6 @@ toast_get_compression_handler(struct varlena *attr) cmid = TOAST_COMPRESS_METHOD(attr); - /* Get the handler routines for the compression method */ switch (cmid) { case PGLZ_COMPRESSION_ID: diff --git a/src/backend/access/compression/compress_lz4.c b/src/backend/access/compression/compress_lz4.c index 1856cf7df7..3079eff7eb 100644 --- a/src/backend/access/compression/compress_lz4.c +++ b/src/backend/access/compression/compress_lz4.c @@ -23,7 +23,7 @@ /* * lz4_cmcompress - compression routine for lz4 compression method * - * Compresses source into dest using the default strategy. Returns the + * Compresses source into dest using the LZ4 defaults. Returns the * compressed varlena, or NULL if compression fails. */ static struct varlena * @@ -42,8 +42,8 @@ lz4_cmcompress(const struct varlena *value) valsize = VARSIZE_ANY_EXHDR(value); /* - * Get maximum size of the compressed data that lz4 compression may output - * and allocate the memory for holding the compressed data and the header. + * 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_COMPRESS); @@ -83,10 +83,10 @@ lz4_cmdecompress(const struct varlena *value) int32 rawsize; struct varlena *result; - /* allocate memory for holding the uncompressed data */ + /* allocate memory for the uncompressed data */ result = (struct varlena *) palloc(VARRAWSIZE_4B_C(value) + VARHDRSZ); - /* decompress data using lz4 routine */ + /* decompress the data */ rawsize = LZ4_decompress_safe((char *) value + VARHDRSZ_COMPRESS, VARDATA(result), VARSIZE(value) - VARHDRSZ_COMPRESS, diff --git a/src/backend/executor/nodeModifyTable.c b/src/backend/executor/nodeModifyTable.c index f77deee399..920d9dd0d5 100644 --- a/src/backend/executor/nodeModifyTable.c +++ b/src/backend/executor/nodeModifyTable.c @@ -2117,7 +2117,7 @@ CompareCompressionMethodAndDecompress(TupleTableSlot *slot, TupleTableSlot *newslot = *outslot; /* - * If the called has passed an invalid slot then create a new slot. + * If the caller has passed an invalid slot then create a new slot. * Otherwise, just clear the existing tuple from the slot. This slot * should be stored by the caller so that it can be reused for * decompressing the subsequent tuples. diff --git a/src/include/nodes/execnodes.h b/src/include/nodes/execnodes.h index 18e8ecfd90..d8483c36b3 100644 --- a/src/include/nodes/execnodes.h +++ b/src/include/nodes/execnodes.h @@ -1183,8 +1183,8 @@ typedef struct ModifyTableState TupleTableSlot *mt_root_tuple_slot; /* - * Slot for storing the modified tuple, incase the target attribute's - * compression method doesn't match with the source table. + * Slot for storing the modified tuple, in case the target attribute's + * compression method doesn't match that of the source table. */ TupleTableSlot *mt_decompress_tuple_slot; -- 2.17.0 --m51xatjYGsM+13rf Content-Type: text/x-diff; charset=us-ascii Content-Disposition: attachment; filename="v24-0006-alter-table-set-compression.patch" ^ permalink raw reply [nested|flat] 51+ messages in thread
* [PATCH 06/12] fixups.patch @ 2021-02-10 21:56 Robert Haas <[email protected]> 0 siblings, 0 replies; 51+ messages in thread From: Robert Haas @ 2021-02-10 21:56 UTC (permalink / raw) --- doc/src/sgml/ddl.sgml | 3 --- doc/src/sgml/ref/create_table.sgml | 15 +++++++++++---- src/backend/access/common/detoast.c | 5 ++--- src/backend/access/compression/compress_lz4.c | 10 +++++----- src/backend/executor/nodeModifyTable.c | 2 +- src/include/nodes/execnodes.h | 4 ++-- 6 files changed, 21 insertions(+), 18 deletions(-) diff --git a/doc/src/sgml/ddl.sgml b/doc/src/sgml/ddl.sgml index 4d7ed698b9..1e9a4625cc 100644 --- a/doc/src/sgml/ddl.sgml +++ b/doc/src/sgml/ddl.sgml @@ -3762,9 +3762,6 @@ CREATE TABLE measurement ( <productname>PostgreSQL</productname> tables (or, possibly, foreign tables). It is possible to specify a tablespace and storage parameters for each partition separately. - By default, each column in a partition inherits the compression method - from parent table's column, however a different compression method can be - set for each partition. </para> <para> diff --git a/doc/src/sgml/ref/create_table.sgml b/doc/src/sgml/ref/create_table.sgml index 3374012940..807597e648 100644 --- a/doc/src/sgml/ref/create_table.sgml +++ b/doc/src/sgml/ref/create_table.sgml @@ -997,10 +997,17 @@ WITH ( MODULUS <replaceable class="parameter">numeric_literal</replaceable>, REM <term><literal>COMPRESSION <replaceable class="parameter">compression_method</replaceable></literal></term> <listitem> <para> - This sets the compression method for a column. The supported compression - methods are <literal>pglz</literal> and <literal>lz4</literal>. - <literal>lz4</literal> is available only if <literal>--with-lz4</literal> - was used when building <productname>PostgreSQL</productname>. The default + The <literal>COMPRESSION</literal> clause sets the compression method + for a column. Compression is supported only for variable-width data + types, and is used only for columns whose storage type is main or + extended. (See <xref linkend="sql-altertable"/> for information on + column storage types.) Setting this property for a partitioned table + has no direct effect, because such tables have no storage of their own, + but the configured value is inherited by newly-created partitions. + The supported compression methods are <literal>pglz</literal> and + <literal>lz4</literal>. <literal>lz4</literal> is available only if + <literal>--with-lz4</literal> was used when building + <productname>PostgreSQL</productname>. The default is <literal>pglz</literal>. </para> </listitem> diff --git a/src/backend/access/common/detoast.c b/src/backend/access/common/detoast.c index b78d49167b..95d5b1c12a 100644 --- a/src/backend/access/common/detoast.c +++ b/src/backend/access/common/detoast.c @@ -477,8 +477,8 @@ toast_get_compression_oid(struct varlena *attr) return InvalidOid; /* - * Just fetch the toast compress header to know the compression method - * in the compressed data. + * Fetch just enough of the value to examine the compression header, + * so that we can find out the compression method. */ attr = toast_fetch_datum_slice(attr, 0, VARHDRSZ_COMPRESS); } @@ -503,7 +503,6 @@ toast_get_compression_handler(struct varlena *attr) cmid = TOAST_COMPRESS_METHOD(attr); - /* Get the handler routines for the compression method */ switch (cmid) { case PGLZ_COMPRESSION_ID: diff --git a/src/backend/access/compression/compress_lz4.c b/src/backend/access/compression/compress_lz4.c index 1856cf7df7..3079eff7eb 100644 --- a/src/backend/access/compression/compress_lz4.c +++ b/src/backend/access/compression/compress_lz4.c @@ -23,7 +23,7 @@ /* * lz4_cmcompress - compression routine for lz4 compression method * - * Compresses source into dest using the default strategy. Returns the + * Compresses source into dest using the LZ4 defaults. Returns the * compressed varlena, or NULL if compression fails. */ static struct varlena * @@ -42,8 +42,8 @@ lz4_cmcompress(const struct varlena *value) valsize = VARSIZE_ANY_EXHDR(value); /* - * Get maximum size of the compressed data that lz4 compression may output - * and allocate the memory for holding the compressed data and the header. + * 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_COMPRESS); @@ -83,10 +83,10 @@ lz4_cmdecompress(const struct varlena *value) int32 rawsize; struct varlena *result; - /* allocate memory for holding the uncompressed data */ + /* allocate memory for the uncompressed data */ result = (struct varlena *) palloc(VARRAWSIZE_4B_C(value) + VARHDRSZ); - /* decompress data using lz4 routine */ + /* decompress the data */ rawsize = LZ4_decompress_safe((char *) value + VARHDRSZ_COMPRESS, VARDATA(result), VARSIZE(value) - VARHDRSZ_COMPRESS, diff --git a/src/backend/executor/nodeModifyTable.c b/src/backend/executor/nodeModifyTable.c index f77deee399..920d9dd0d5 100644 --- a/src/backend/executor/nodeModifyTable.c +++ b/src/backend/executor/nodeModifyTable.c @@ -2117,7 +2117,7 @@ CompareCompressionMethodAndDecompress(TupleTableSlot *slot, TupleTableSlot *newslot = *outslot; /* - * If the called has passed an invalid slot then create a new slot. + * If the caller has passed an invalid slot then create a new slot. * Otherwise, just clear the existing tuple from the slot. This slot * should be stored by the caller so that it can be reused for * decompressing the subsequent tuples. diff --git a/src/include/nodes/execnodes.h b/src/include/nodes/execnodes.h index ac3884b3a8..182b77a0ff 100644 --- a/src/include/nodes/execnodes.h +++ b/src/include/nodes/execnodes.h @@ -1186,8 +1186,8 @@ typedef struct ModifyTableState TupleTableSlot *mt_root_tuple_slot; /* - * Slot for storing the modified tuple, incase the target attribute's - * compression method doesn't match with the source table. + * Slot for storing the modified tuple, in case the target attribute's + * compression method doesn't match that of the source table. */ TupleTableSlot *mt_decompress_tuple_slot; -- 2.17.0 --9Ek0hoCL9XbhcSqy Content-Type: text/x-diff; charset=us-ascii Content-Disposition: attachment; filename="0007-alter-table-set-compression.patch" ^ permalink raw reply [nested|flat] 51+ messages in thread
* [PATCH v24 05/10] fixups.patch @ 2021-02-10 21:56 Robert Haas <[email protected]> 0 siblings, 0 replies; 51+ messages in thread From: Robert Haas @ 2021-02-10 21:56 UTC (permalink / raw) --- doc/src/sgml/ddl.sgml | 3 --- doc/src/sgml/ref/create_table.sgml | 15 +++++++++++---- src/backend/access/common/detoast.c | 5 ++--- src/backend/access/compression/compress_lz4.c | 10 +++++----- src/backend/executor/nodeModifyTable.c | 2 +- src/include/nodes/execnodes.h | 4 ++-- 6 files changed, 21 insertions(+), 18 deletions(-) diff --git a/doc/src/sgml/ddl.sgml b/doc/src/sgml/ddl.sgml index 4d7ed698b9..1e9a4625cc 100644 --- a/doc/src/sgml/ddl.sgml +++ b/doc/src/sgml/ddl.sgml @@ -3762,9 +3762,6 @@ CREATE TABLE measurement ( <productname>PostgreSQL</productname> tables (or, possibly, foreign tables). It is possible to specify a tablespace and storage parameters for each partition separately. - By default, each column in a partition inherits the compression method - from parent table's column, however a different compression method can be - set for each partition. </para> <para> diff --git a/doc/src/sgml/ref/create_table.sgml b/doc/src/sgml/ref/create_table.sgml index 51a7a977a5..a4b297340f 100644 --- a/doc/src/sgml/ref/create_table.sgml +++ b/doc/src/sgml/ref/create_table.sgml @@ -997,10 +997,17 @@ WITH ( MODULUS <replaceable class="parameter">numeric_literal</replaceable>, REM <term><literal>COMPRESSION <replaceable class="parameter">compression_method</replaceable></literal></term> <listitem> <para> - This sets the compression method for a column. The supported compression - methods are <literal>pglz</literal> and <literal>lz4</literal>. - <literal>lz4</literal> is available only if <literal>--with-lz4</literal> - was used when building <productname>PostgreSQL</productname>. The default + The <literal>COMPRESSION</literal> clause sets the compression method + for a column. Compression is supported only for variable-width data + types, and is used only for columns whose storage type is main or + extended. (See <xref linkend="sql-altertable"/> for information on + column storage types.) Setting this property for a partitioned table + has no direct effect, because such tables have no storage of their own, + but the configured value is inherited by newly-created partitions. + The supported compression methods are <literal>pglz</literal> and + <literal>lz4</literal>. <literal>lz4</literal> is available only if + <literal>--with-lz4</literal> was used when building + <productname>PostgreSQL</productname>. The default is <literal>pglz</literal>. </para> </listitem> diff --git a/src/backend/access/common/detoast.c b/src/backend/access/common/detoast.c index b78d49167b..95d5b1c12a 100644 --- a/src/backend/access/common/detoast.c +++ b/src/backend/access/common/detoast.c @@ -477,8 +477,8 @@ toast_get_compression_oid(struct varlena *attr) return InvalidOid; /* - * Just fetch the toast compress header to know the compression method - * in the compressed data. + * Fetch just enough of the value to examine the compression header, + * so that we can find out the compression method. */ attr = toast_fetch_datum_slice(attr, 0, VARHDRSZ_COMPRESS); } @@ -503,7 +503,6 @@ toast_get_compression_handler(struct varlena *attr) cmid = TOAST_COMPRESS_METHOD(attr); - /* Get the handler routines for the compression method */ switch (cmid) { case PGLZ_COMPRESSION_ID: diff --git a/src/backend/access/compression/compress_lz4.c b/src/backend/access/compression/compress_lz4.c index 1856cf7df7..3079eff7eb 100644 --- a/src/backend/access/compression/compress_lz4.c +++ b/src/backend/access/compression/compress_lz4.c @@ -23,7 +23,7 @@ /* * lz4_cmcompress - compression routine for lz4 compression method * - * Compresses source into dest using the default strategy. Returns the + * Compresses source into dest using the LZ4 defaults. Returns the * compressed varlena, or NULL if compression fails. */ static struct varlena * @@ -42,8 +42,8 @@ lz4_cmcompress(const struct varlena *value) valsize = VARSIZE_ANY_EXHDR(value); /* - * Get maximum size of the compressed data that lz4 compression may output - * and allocate the memory for holding the compressed data and the header. + * 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_COMPRESS); @@ -83,10 +83,10 @@ lz4_cmdecompress(const struct varlena *value) int32 rawsize; struct varlena *result; - /* allocate memory for holding the uncompressed data */ + /* allocate memory for the uncompressed data */ result = (struct varlena *) palloc(VARRAWSIZE_4B_C(value) + VARHDRSZ); - /* decompress data using lz4 routine */ + /* decompress the data */ rawsize = LZ4_decompress_safe((char *) value + VARHDRSZ_COMPRESS, VARDATA(result), VARSIZE(value) - VARHDRSZ_COMPRESS, diff --git a/src/backend/executor/nodeModifyTable.c b/src/backend/executor/nodeModifyTable.c index f77deee399..920d9dd0d5 100644 --- a/src/backend/executor/nodeModifyTable.c +++ b/src/backend/executor/nodeModifyTable.c @@ -2117,7 +2117,7 @@ CompareCompressionMethodAndDecompress(TupleTableSlot *slot, TupleTableSlot *newslot = *outslot; /* - * If the called has passed an invalid slot then create a new slot. + * If the caller has passed an invalid slot then create a new slot. * Otherwise, just clear the existing tuple from the slot. This slot * should be stored by the caller so that it can be reused for * decompressing the subsequent tuples. diff --git a/src/include/nodes/execnodes.h b/src/include/nodes/execnodes.h index 18e8ecfd90..d8483c36b3 100644 --- a/src/include/nodes/execnodes.h +++ b/src/include/nodes/execnodes.h @@ -1183,8 +1183,8 @@ typedef struct ModifyTableState TupleTableSlot *mt_root_tuple_slot; /* - * Slot for storing the modified tuple, incase the target attribute's - * compression method doesn't match with the source table. + * Slot for storing the modified tuple, in case the target attribute's + * compression method doesn't match that of the source table. */ TupleTableSlot *mt_decompress_tuple_slot; -- 2.17.0 --m51xatjYGsM+13rf Content-Type: text/x-diff; charset=us-ascii Content-Disposition: attachment; filename="v24-0006-alter-table-set-compression.patch" ^ permalink raw reply [nested|flat] 51+ messages in thread
* [PATCH v24 5/7] fixups.patch @ 2021-02-10 21:56 Robert Haas <[email protected]> 0 siblings, 0 replies; 51+ messages in thread From: Robert Haas @ 2021-02-10 21:56 UTC (permalink / raw) --- doc/src/sgml/ddl.sgml | 3 --- doc/src/sgml/ref/create_table.sgml | 15 +++++++++++---- src/backend/access/common/detoast.c | 5 ++--- src/backend/access/compression/compress_lz4.c | 10 +++++----- src/backend/executor/nodeModifyTable.c | 2 +- src/include/nodes/execnodes.h | 4 ++-- 6 files changed, 21 insertions(+), 18 deletions(-) diff --git a/doc/src/sgml/ddl.sgml b/doc/src/sgml/ddl.sgml index 4d7ed698b9..1e9a4625cc 100644 --- a/doc/src/sgml/ddl.sgml +++ b/doc/src/sgml/ddl.sgml @@ -3762,9 +3762,6 @@ CREATE TABLE measurement ( <productname>PostgreSQL</productname> tables (or, possibly, foreign tables). It is possible to specify a tablespace and storage parameters for each partition separately. - By default, each column in a partition inherits the compression method - from parent table's column, however a different compression method can be - set for each partition. </para> <para> diff --git a/doc/src/sgml/ref/create_table.sgml b/doc/src/sgml/ref/create_table.sgml index 51a7a977a5..a4b297340f 100644 --- a/doc/src/sgml/ref/create_table.sgml +++ b/doc/src/sgml/ref/create_table.sgml @@ -997,10 +997,17 @@ WITH ( MODULUS <replaceable class="parameter">numeric_literal</replaceable>, REM <term><literal>COMPRESSION <replaceable class="parameter">compression_method</replaceable></literal></term> <listitem> <para> - This sets the compression method for a column. The supported compression - methods are <literal>pglz</literal> and <literal>lz4</literal>. - <literal>lz4</literal> is available only if <literal>--with-lz4</literal> - was used when building <productname>PostgreSQL</productname>. The default + The <literal>COMPRESSION</literal> clause sets the compression method + for a column. Compression is supported only for variable-width data + types, and is used only for columns whose storage type is main or + extended. (See <xref linkend="sql-altertable"/> for information on + column storage types.) Setting this property for a partitioned table + has no direct effect, because such tables have no storage of their own, + but the configured value is inherited by newly-created partitions. + The supported compression methods are <literal>pglz</literal> and + <literal>lz4</literal>. <literal>lz4</literal> is available only if + <literal>--with-lz4</literal> was used when building + <productname>PostgreSQL</productname>. The default is <literal>pglz</literal>. </para> </listitem> diff --git a/src/backend/access/common/detoast.c b/src/backend/access/common/detoast.c index b78d49167b..95d5b1c12a 100644 --- a/src/backend/access/common/detoast.c +++ b/src/backend/access/common/detoast.c @@ -477,8 +477,8 @@ toast_get_compression_oid(struct varlena *attr) return InvalidOid; /* - * Just fetch the toast compress header to know the compression method - * in the compressed data. + * Fetch just enough of the value to examine the compression header, + * so that we can find out the compression method. */ attr = toast_fetch_datum_slice(attr, 0, VARHDRSZ_COMPRESS); } @@ -503,7 +503,6 @@ toast_get_compression_handler(struct varlena *attr) cmid = TOAST_COMPRESS_METHOD(attr); - /* Get the handler routines for the compression method */ switch (cmid) { case PGLZ_COMPRESSION_ID: diff --git a/src/backend/access/compression/compress_lz4.c b/src/backend/access/compression/compress_lz4.c index 1856cf7df7..3079eff7eb 100644 --- a/src/backend/access/compression/compress_lz4.c +++ b/src/backend/access/compression/compress_lz4.c @@ -23,7 +23,7 @@ /* * lz4_cmcompress - compression routine for lz4 compression method * - * Compresses source into dest using the default strategy. Returns the + * Compresses source into dest using the LZ4 defaults. Returns the * compressed varlena, or NULL if compression fails. */ static struct varlena * @@ -42,8 +42,8 @@ lz4_cmcompress(const struct varlena *value) valsize = VARSIZE_ANY_EXHDR(value); /* - * Get maximum size of the compressed data that lz4 compression may output - * and allocate the memory for holding the compressed data and the header. + * 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_COMPRESS); @@ -83,10 +83,10 @@ lz4_cmdecompress(const struct varlena *value) int32 rawsize; struct varlena *result; - /* allocate memory for holding the uncompressed data */ + /* allocate memory for the uncompressed data */ result = (struct varlena *) palloc(VARRAWSIZE_4B_C(value) + VARHDRSZ); - /* decompress data using lz4 routine */ + /* decompress the data */ rawsize = LZ4_decompress_safe((char *) value + VARHDRSZ_COMPRESS, VARDATA(result), VARSIZE(value) - VARHDRSZ_COMPRESS, diff --git a/src/backend/executor/nodeModifyTable.c b/src/backend/executor/nodeModifyTable.c index f77deee399..920d9dd0d5 100644 --- a/src/backend/executor/nodeModifyTable.c +++ b/src/backend/executor/nodeModifyTable.c @@ -2117,7 +2117,7 @@ CompareCompressionMethodAndDecompress(TupleTableSlot *slot, TupleTableSlot *newslot = *outslot; /* - * If the called has passed an invalid slot then create a new slot. + * If the caller has passed an invalid slot then create a new slot. * Otherwise, just clear the existing tuple from the slot. This slot * should be stored by the caller so that it can be reused for * decompressing the subsequent tuples. diff --git a/src/include/nodes/execnodes.h b/src/include/nodes/execnodes.h index 18e8ecfd90..d8483c36b3 100644 --- a/src/include/nodes/execnodes.h +++ b/src/include/nodes/execnodes.h @@ -1183,8 +1183,8 @@ typedef struct ModifyTableState TupleTableSlot *mt_root_tuple_slot; /* - * Slot for storing the modified tuple, incase the target attribute's - * compression method doesn't match with the source table. + * Slot for storing the modified tuple, in case the target attribute's + * compression method doesn't match that of the source table. */ TupleTableSlot *mt_decompress_tuple_slot; -- 2.17.0 --YZ5djTAD1cGYuMQK Content-Type: text/x-diff; charset=us-ascii Content-Disposition: attachment; filename="v24-0006-alter-table-set-compression.patch" ^ permalink raw reply [nested|flat] 51+ messages in thread
* [PATCH v24 05/10] fixups.patch @ 2021-02-10 21:56 Robert Haas <[email protected]> 0 siblings, 0 replies; 51+ messages in thread From: Robert Haas @ 2021-02-10 21:56 UTC (permalink / raw) --- doc/src/sgml/ddl.sgml | 3 --- doc/src/sgml/ref/create_table.sgml | 15 +++++++++++---- src/backend/access/common/detoast.c | 5 ++--- src/backend/access/compression/compress_lz4.c | 10 +++++----- src/backend/executor/nodeModifyTable.c | 2 +- src/include/nodes/execnodes.h | 4 ++-- 6 files changed, 21 insertions(+), 18 deletions(-) diff --git a/doc/src/sgml/ddl.sgml b/doc/src/sgml/ddl.sgml index 4d7ed698b9..1e9a4625cc 100644 --- a/doc/src/sgml/ddl.sgml +++ b/doc/src/sgml/ddl.sgml @@ -3762,9 +3762,6 @@ CREATE TABLE measurement ( <productname>PostgreSQL</productname> tables (or, possibly, foreign tables). It is possible to specify a tablespace and storage parameters for each partition separately. - By default, each column in a partition inherits the compression method - from parent table's column, however a different compression method can be - set for each partition. </para> <para> diff --git a/doc/src/sgml/ref/create_table.sgml b/doc/src/sgml/ref/create_table.sgml index 51a7a977a5..a4b297340f 100644 --- a/doc/src/sgml/ref/create_table.sgml +++ b/doc/src/sgml/ref/create_table.sgml @@ -997,10 +997,17 @@ WITH ( MODULUS <replaceable class="parameter">numeric_literal</replaceable>, REM <term><literal>COMPRESSION <replaceable class="parameter">compression_method</replaceable></literal></term> <listitem> <para> - This sets the compression method for a column. The supported compression - methods are <literal>pglz</literal> and <literal>lz4</literal>. - <literal>lz4</literal> is available only if <literal>--with-lz4</literal> - was used when building <productname>PostgreSQL</productname>. The default + The <literal>COMPRESSION</literal> clause sets the compression method + for a column. Compression is supported only for variable-width data + types, and is used only for columns whose storage type is main or + extended. (See <xref linkend="sql-altertable"/> for information on + column storage types.) Setting this property for a partitioned table + has no direct effect, because such tables have no storage of their own, + but the configured value is inherited by newly-created partitions. + The supported compression methods are <literal>pglz</literal> and + <literal>lz4</literal>. <literal>lz4</literal> is available only if + <literal>--with-lz4</literal> was used when building + <productname>PostgreSQL</productname>. The default is <literal>pglz</literal>. </para> </listitem> diff --git a/src/backend/access/common/detoast.c b/src/backend/access/common/detoast.c index b78d49167b..95d5b1c12a 100644 --- a/src/backend/access/common/detoast.c +++ b/src/backend/access/common/detoast.c @@ -477,8 +477,8 @@ toast_get_compression_oid(struct varlena *attr) return InvalidOid; /* - * Just fetch the toast compress header to know the compression method - * in the compressed data. + * Fetch just enough of the value to examine the compression header, + * so that we can find out the compression method. */ attr = toast_fetch_datum_slice(attr, 0, VARHDRSZ_COMPRESS); } @@ -503,7 +503,6 @@ toast_get_compression_handler(struct varlena *attr) cmid = TOAST_COMPRESS_METHOD(attr); - /* Get the handler routines for the compression method */ switch (cmid) { case PGLZ_COMPRESSION_ID: diff --git a/src/backend/access/compression/compress_lz4.c b/src/backend/access/compression/compress_lz4.c index 1856cf7df7..3079eff7eb 100644 --- a/src/backend/access/compression/compress_lz4.c +++ b/src/backend/access/compression/compress_lz4.c @@ -23,7 +23,7 @@ /* * lz4_cmcompress - compression routine for lz4 compression method * - * Compresses source into dest using the default strategy. Returns the + * Compresses source into dest using the LZ4 defaults. Returns the * compressed varlena, or NULL if compression fails. */ static struct varlena * @@ -42,8 +42,8 @@ lz4_cmcompress(const struct varlena *value) valsize = VARSIZE_ANY_EXHDR(value); /* - * Get maximum size of the compressed data that lz4 compression may output - * and allocate the memory for holding the compressed data and the header. + * 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_COMPRESS); @@ -83,10 +83,10 @@ lz4_cmdecompress(const struct varlena *value) int32 rawsize; struct varlena *result; - /* allocate memory for holding the uncompressed data */ + /* allocate memory for the uncompressed data */ result = (struct varlena *) palloc(VARRAWSIZE_4B_C(value) + VARHDRSZ); - /* decompress data using lz4 routine */ + /* decompress the data */ rawsize = LZ4_decompress_safe((char *) value + VARHDRSZ_COMPRESS, VARDATA(result), VARSIZE(value) - VARHDRSZ_COMPRESS, diff --git a/src/backend/executor/nodeModifyTable.c b/src/backend/executor/nodeModifyTable.c index f77deee399..920d9dd0d5 100644 --- a/src/backend/executor/nodeModifyTable.c +++ b/src/backend/executor/nodeModifyTable.c @@ -2117,7 +2117,7 @@ CompareCompressionMethodAndDecompress(TupleTableSlot *slot, TupleTableSlot *newslot = *outslot; /* - * If the called has passed an invalid slot then create a new slot. + * If the caller has passed an invalid slot then create a new slot. * Otherwise, just clear the existing tuple from the slot. This slot * should be stored by the caller so that it can be reused for * decompressing the subsequent tuples. diff --git a/src/include/nodes/execnodes.h b/src/include/nodes/execnodes.h index 18e8ecfd90..d8483c36b3 100644 --- a/src/include/nodes/execnodes.h +++ b/src/include/nodes/execnodes.h @@ -1183,8 +1183,8 @@ typedef struct ModifyTableState TupleTableSlot *mt_root_tuple_slot; /* - * Slot for storing the modified tuple, incase the target attribute's - * compression method doesn't match with the source table. + * Slot for storing the modified tuple, in case the target attribute's + * compression method doesn't match that of the source table. */ TupleTableSlot *mt_decompress_tuple_slot; -- 2.17.0 --m51xatjYGsM+13rf Content-Type: text/x-diff; charset=us-ascii Content-Disposition: attachment; filename="v24-0006-alter-table-set-compression.patch" ^ permalink raw reply [nested|flat] 51+ messages in thread
* meson: pkgconfig difference @ 2023-02-01 07:40 Peter Eisentraut <[email protected]> 0 siblings, 1 reply; 51+ messages in thread From: Peter Eisentraut @ 2023-02-01 07:40 UTC (permalink / raw) To: pgsql-hackers I think there is a tiny typo in src/interfaces/ecpg/ecpglib/meson.build: diff --git a/src/interfaces/ecpg/ecpglib/meson.build b/src/interfaces/ecpg/ecpglib/meson.build index dba9e3c3d9..da8d304f54 100644 --- a/src/interfaces/ecpg/ecpglib/meson.build +++ b/src/interfaces/ecpg/ecpglib/meson.build @@ -57,7 +57,7 @@ pkgconfig.generate( description: 'PostgreSQL libecpg library', url: pg_url, libraries: ecpglib_so, - libraries_private: [frontend_shlib_code, thread_dep], + libraries_private: [frontend_stlib_code, thread_dep], requires_private: ['libpgtypes', 'libpq'], ) This makes it match the other libraries. Without this change, we get Libs.private: ... -lpgport_shlib -lpgcommon_shlib which seems wrong. ^ permalink raw reply [nested|flat] 51+ messages in thread
* Re: meson: pkgconfig difference @ 2023-02-01 07:55 Andres Freund <[email protected]> parent: Peter Eisentraut <[email protected]> 0 siblings, 1 reply; 51+ messages in thread From: Andres Freund @ 2023-02-01 07:55 UTC (permalink / raw) To: [email protected]; Peter Eisentraut <[email protected]>; pgsql-hackers Hi, On January 31, 2023 11:40:52 PM PST, Peter Eisentraut <[email protected]> wrote: >I think there is a tiny typo in src/interfaces/ecpg/ecpglib/meson.build: > >diff --git a/src/interfaces/ecpg/ecpglib/meson.build b/src/interfaces/ecpg/ecpglib/meson.build >index dba9e3c3d9..da8d304f54 100644 >--- a/src/interfaces/ecpg/ecpglib/meson.build >+++ b/src/interfaces/ecpg/ecpglib/meson.build >@@ -57,7 +57,7 @@ pkgconfig.generate( > description: 'PostgreSQL libecpg library', > url: pg_url, > libraries: ecpglib_so, >- libraries_private: [frontend_shlib_code, thread_dep], >+ libraries_private: [frontend_stlib_code, thread_dep], > requires_private: ['libpgtypes', 'libpq'], > ) > >This makes it match the other libraries. > >Without this change, we get > >Libs.private: ... -lpgport_shlib -lpgcommon_shlib > >which seems wrong. Ugh, yes, that's wrong. Do you want me to apply the fix? Regards, Andres -- Sent from my Android device with K-9 Mail. Please excuse my brevity. ^ permalink raw reply [nested|flat] 51+ messages in thread
* Re: meson: pkgconfig difference @ 2023-02-01 17:15 Peter Eisentraut <[email protected]> parent: Andres Freund <[email protected]> 0 siblings, 0 replies; 51+ messages in thread From: Peter Eisentraut @ 2023-02-01 17:15 UTC (permalink / raw) To: Andres Freund <[email protected]>; pgsql-hackers On 01.02.23 08:55, Andres Freund wrote: > Hi, > > On January 31, 2023 11:40:52 PM PST, Peter Eisentraut <[email protected]> wrote: >> I think there is a tiny typo in src/interfaces/ecpg/ecpglib/meson.build: >> >> diff --git a/src/interfaces/ecpg/ecpglib/meson.build b/src/interfaces/ecpg/ecpglib/meson.build >> index dba9e3c3d9..da8d304f54 100644 >> --- a/src/interfaces/ecpg/ecpglib/meson.build >> +++ b/src/interfaces/ecpg/ecpglib/meson.build >> @@ -57,7 +57,7 @@ pkgconfig.generate( >> description: 'PostgreSQL libecpg library', >> url: pg_url, >> libraries: ecpglib_so, >> - libraries_private: [frontend_shlib_code, thread_dep], >> + libraries_private: [frontend_stlib_code, thread_dep], >> requires_private: ['libpgtypes', 'libpq'], >> ) >> >> This makes it match the other libraries. >> >> Without this change, we get >> >> Libs.private: ... -lpgport_shlib -lpgcommon_shlib >> >> which seems wrong. > > Ugh, yes, that's wrong. Do you want me to apply the fix? I've done it now. ^ permalink raw reply [nested|flat] 51+ messages in thread
end of thread, other threads:[~2023-02-01 17:15 UTC | newest] Thread overview: 51+ messages (download: mbox mbox.gz follow: Atom feed) -- links below jump to the message on this page -- 2017-06-27 05:26 Incorrect mentions to pg_xlog in walmethods.c/h Michael Paquier <[email protected]> 2017-06-30 18:41 ` Peter Eisentraut <[email protected]> 2017-06-30 23:56 ` Michael Paquier <[email protected]> 2021-02-10 21:56 [PATCH v24 05/10] fixups.patch Robert Haas <[email protected]> 2021-02-10 21:56 [PATCH v24 05/10] fixups.patch Robert Haas <[email protected]> 2021-02-10 21:56 [PATCH v24 5/7] fixups.patch Robert Haas <[email protected]> 2021-02-10 21:56 [PATCH v24 5/7] fixups.patch Robert Haas <[email protected]> 2021-02-10 21:56 [PATCH v24 05/10] fixups.patch Robert Haas <[email protected]> 2021-02-10 21:56 [PATCH v24 5/7] fixups.patch Robert Haas <[email protected]> 2021-02-10 21:56 [PATCH v24 05/10] fixups.patch Robert Haas <[email protected]> 2021-02-10 21:56 [PATCH v24 5/7] fixups.patch Robert Haas <[email protected]> 2021-02-10 21:56 [PATCH v24 05/10] fixups.patch Robert Haas <[email protected]> 2021-02-10 21:56 [PATCH v24 5/7] fixups.patch Robert Haas <[email protected]> 2021-02-10 21:56 [PATCH v24 5/7] fixups.patch Robert Haas <[email protected]> 2021-02-10 21:56 [PATCH v24 05/10] fixups.patch Robert Haas <[email protected]> 2021-02-10 21:56 [PATCH v24 05/10] fixups.patch Robert Haas <[email protected]> 2021-02-10 21:56 [PATCH v24 05/10] fixups.patch Robert Haas <[email protected]> 2021-02-10 21:56 [PATCH v24 5/7] fixups.patch Robert Haas <[email protected]> 2021-02-10 21:56 [PATCH v24 05/10] fixups.patch Robert Haas <[email protected]> 2021-02-10 21:56 [PATCH v24 5/7] fixups.patch Robert Haas <[email protected]> 2021-02-10 21:56 [PATCH v24 05/10] fixups.patch Robert Haas <[email protected]> 2021-02-10 21:56 [PATCH v24 05/10] fixups.patch Robert Haas <[email protected]> 2021-02-10 21:56 [PATCH v24 5/7] fixups.patch Robert Haas <[email protected]> 2021-02-10 21:56 [PATCH v24 5/7] fixups.patch Robert Haas <[email protected]> 2021-02-10 21:56 [PATCH v24 05/10] fixups.patch Robert Haas <[email protected]> 2021-02-10 21:56 [PATCH v24 5/7] fixups.patch Robert Haas <[email protected]> 2021-02-10 21:56 [PATCH v24 5/7] fixups.patch Robert Haas <[email protected]> 2021-02-10 21:56 [PATCH 06/12] fixups.patch Robert Haas <[email protected]> 2021-02-10 21:56 [PATCH v24 5/7] fixups.patch Robert Haas <[email protected]> 2021-02-10 21:56 [PATCH v24 5/7] fixups.patch Robert Haas <[email protected]> 2021-02-10 21:56 [PATCH v24 05/10] fixups.patch Robert Haas <[email protected]> 2021-02-10 21:56 [PATCH v24 05/10] fixups.patch Robert Haas <[email protected]> 2021-02-10 21:56 [PATCH v24 5/7] fixups.patch Robert Haas <[email protected]> 2021-02-10 21:56 [PATCH v24 05/10] fixups.patch Robert Haas <[email protected]> 2021-02-10 21:56 [PATCH v24 5/7] fixups.patch Robert Haas <[email protected]> 2021-02-10 21:56 [PATCH v24 05/10] fixups.patch Robert Haas <[email protected]> 2021-02-10 21:56 [PATCH v24 05/10] fixups.patch Robert Haas <[email protected]> 2021-02-10 21:56 [PATCH v24 5/7] fixups.patch Robert Haas <[email protected]> 2021-02-10 21:56 [PATCH v24 5/7] fixups.patch Robert Haas <[email protected]> 2021-02-10 21:56 [PATCH v24 5/7] fixups.patch Robert Haas <[email protected]> 2021-02-10 21:56 [PATCH v24 05/10] fixups.patch Robert Haas <[email protected]> 2021-02-10 21:56 [PATCH v24 5/7] fixups.patch Robert Haas <[email protected]> 2021-02-10 21:56 [PATCH v24 5/7] fixups.patch Robert Haas <[email protected]> 2021-02-10 21:56 [PATCH v24 05/10] fixups.patch Robert Haas <[email protected]> 2021-02-10 21:56 [PATCH v24 05/10] fixups.patch Robert Haas <[email protected]> 2021-02-10 21:56 [PATCH v24 05/10] fixups.patch Robert Haas <[email protected]> 2021-02-10 21:56 [PATCH v24 05/10] fixups.patch Robert Haas <[email protected]> 2021-02-10 21:56 [PATCH v24 5/7] fixups.patch Robert Haas <[email protected]> 2023-02-01 07:40 meson: pkgconfig difference Peter Eisentraut <[email protected]> 2023-02-01 07:55 ` Re: meson: pkgconfig difference Andres Freund <[email protected]> 2023-02-01 17:15 ` Re: meson: pkgconfig difference Peter Eisentraut <[email protected]>
This inbox is served by agora; see mirroring instructions for how to clone and mirror all data and code used for this inbox