agora inbox for [email protected]
help / color / mirror / Atom feed[PATCH v24 5/7] fixups.patch
46+ messages / 2 participants
[nested] [flat]
* [PATCH v24 5/7] fixups.patch
@ 2021-02-10 21:56 Robert Haas <[email protected]>
0 siblings, 0 replies; 46+ 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] 46+ messages in thread
* [PATCH v24 5/7] fixups.patch
@ 2021-02-10 21:56 Robert Haas <[email protected]>
0 siblings, 0 replies; 46+ 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] 46+ messages in thread
* [PATCH v24 05/10] fixups.patch
@ 2021-02-10 21:56 Robert Haas <[email protected]>
0 siblings, 0 replies; 46+ 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] 46+ messages in thread
* [PATCH v24 5/7] fixups.patch
@ 2021-02-10 21:56 Robert Haas <[email protected]>
0 siblings, 0 replies; 46+ 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] 46+ messages in thread
* [PATCH v24 05/10] fixups.patch
@ 2021-02-10 21:56 Robert Haas <[email protected]>
0 siblings, 0 replies; 46+ 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] 46+ messages in thread
* [PATCH v24 05/10] fixups.patch
@ 2021-02-10 21:56 Robert Haas <[email protected]>
0 siblings, 0 replies; 46+ 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] 46+ messages in thread
* [PATCH v24 5/7] fixups.patch
@ 2021-02-10 21:56 Robert Haas <[email protected]>
0 siblings, 0 replies; 46+ 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] 46+ messages in thread
* [PATCH v24 05/10] fixups.patch
@ 2021-02-10 21:56 Robert Haas <[email protected]>
0 siblings, 0 replies; 46+ 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] 46+ messages in thread
* [PATCH v24 05/10] fixups.patch
@ 2021-02-10 21:56 Robert Haas <[email protected]>
0 siblings, 0 replies; 46+ 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] 46+ messages in thread
* [PATCH v24 5/7] fixups.patch
@ 2021-02-10 21:56 Robert Haas <[email protected]>
0 siblings, 0 replies; 46+ 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] 46+ messages in thread
* [PATCH v24 5/7] fixups.patch
@ 2021-02-10 21:56 Robert Haas <[email protected]>
0 siblings, 0 replies; 46+ 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] 46+ messages in thread
* [PATCH v24 5/7] fixups.patch
@ 2021-02-10 21:56 Robert Haas <[email protected]>
0 siblings, 0 replies; 46+ 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] 46+ messages in thread
* [PATCH v24 05/10] fixups.patch
@ 2021-02-10 21:56 Robert Haas <[email protected]>
0 siblings, 0 replies; 46+ 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] 46+ messages in thread
* [PATCH v24 05/10] fixups.patch
@ 2021-02-10 21:56 Robert Haas <[email protected]>
0 siblings, 0 replies; 46+ 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] 46+ messages in thread
* [PATCH v24 5/7] fixups.patch
@ 2021-02-10 21:56 Robert Haas <[email protected]>
0 siblings, 0 replies; 46+ 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] 46+ messages in thread
* [PATCH v24 05/10] fixups.patch
@ 2021-02-10 21:56 Robert Haas <[email protected]>
0 siblings, 0 replies; 46+ 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] 46+ messages in thread
* [PATCH v24 5/7] fixups.patch
@ 2021-02-10 21:56 Robert Haas <[email protected]>
0 siblings, 0 replies; 46+ 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] 46+ messages in thread
* [PATCH v24 5/7] fixups.patch
@ 2021-02-10 21:56 Robert Haas <[email protected]>
0 siblings, 0 replies; 46+ 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] 46+ messages in thread
* [PATCH v24 05/10] fixups.patch
@ 2021-02-10 21:56 Robert Haas <[email protected]>
0 siblings, 0 replies; 46+ 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] 46+ messages in thread
* [PATCH v24 5/7] fixups.patch
@ 2021-02-10 21:56 Robert Haas <[email protected]>
0 siblings, 0 replies; 46+ 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] 46+ messages in thread
* [PATCH v24 5/7] fixups.patch
@ 2021-02-10 21:56 Robert Haas <[email protected]>
0 siblings, 0 replies; 46+ 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] 46+ messages in thread
* [PATCH v24 5/7] fixups.patch
@ 2021-02-10 21:56 Robert Haas <[email protected]>
0 siblings, 0 replies; 46+ 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] 46+ messages in thread
* [PATCH v24 05/10] fixups.patch
@ 2021-02-10 21:56 Robert Haas <[email protected]>
0 siblings, 0 replies; 46+ 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] 46+ messages in thread
* [PATCH v24 05/10] fixups.patch
@ 2021-02-10 21:56 Robert Haas <[email protected]>
0 siblings, 0 replies; 46+ 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] 46+ messages in thread
* [PATCH v24 5/7] fixups.patch
@ 2021-02-10 21:56 Robert Haas <[email protected]>
0 siblings, 0 replies; 46+ 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] 46+ messages in thread
* [PATCH v24 05/10] fixups.patch
@ 2021-02-10 21:56 Robert Haas <[email protected]>
0 siblings, 0 replies; 46+ 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] 46+ messages in thread
* [PATCH v24 05/10] fixups.patch
@ 2021-02-10 21:56 Robert Haas <[email protected]>
0 siblings, 0 replies; 46+ 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] 46+ messages in thread
* [PATCH v24 05/10] fixups.patch
@ 2021-02-10 21:56 Robert Haas <[email protected]>
0 siblings, 0 replies; 46+ 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] 46+ messages in thread
* [PATCH v24 05/10] fixups.patch
@ 2021-02-10 21:56 Robert Haas <[email protected]>
0 siblings, 0 replies; 46+ 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] 46+ messages in thread
* [PATCH v24 5/7] fixups.patch
@ 2021-02-10 21:56 Robert Haas <[email protected]>
0 siblings, 0 replies; 46+ 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] 46+ messages in thread
* [PATCH v24 5/7] fixups.patch
@ 2021-02-10 21:56 Robert Haas <[email protected]>
0 siblings, 0 replies; 46+ 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] 46+ messages in thread
* [PATCH v24 5/7] fixups.patch
@ 2021-02-10 21:56 Robert Haas <[email protected]>
0 siblings, 0 replies; 46+ 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] 46+ messages in thread
* [PATCH v24 05/10] fixups.patch
@ 2021-02-10 21:56 Robert Haas <[email protected]>
0 siblings, 0 replies; 46+ 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] 46+ messages in thread
* [PATCH v24 05/10] fixups.patch
@ 2021-02-10 21:56 Robert Haas <[email protected]>
0 siblings, 0 replies; 46+ 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] 46+ messages in thread
* [PATCH 06/12] fixups.patch
@ 2021-02-10 21:56 Robert Haas <[email protected]>
0 siblings, 0 replies; 46+ 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] 46+ messages in thread
* [PATCH v24 05/10] fixups.patch
@ 2021-02-10 21:56 Robert Haas <[email protected]>
0 siblings, 0 replies; 46+ 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] 46+ messages in thread
* [PATCH v24 05/10] fixups.patch
@ 2021-02-10 21:56 Robert Haas <[email protected]>
0 siblings, 0 replies; 46+ 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] 46+ messages in thread
* [PATCH v24 5/7] fixups.patch
@ 2021-02-10 21:56 Robert Haas <[email protected]>
0 siblings, 0 replies; 46+ 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] 46+ messages in thread
* [PATCH v24 5/7] fixups.patch
@ 2021-02-10 21:56 Robert Haas <[email protected]>
0 siblings, 0 replies; 46+ 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] 46+ messages in thread
* [PATCH v24 05/10] fixups.patch
@ 2021-02-10 21:56 Robert Haas <[email protected]>
0 siblings, 0 replies; 46+ 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] 46+ messages in thread
* [PATCH v24 5/7] fixups.patch
@ 2021-02-10 21:56 Robert Haas <[email protected]>
0 siblings, 0 replies; 46+ 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] 46+ messages in thread
* [PATCH v24 05/10] fixups.patch
@ 2021-02-10 21:56 Robert Haas <[email protected]>
0 siblings, 0 replies; 46+ 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] 46+ messages in thread
* [PATCH v24 5/7] fixups.patch
@ 2021-02-10 21:56 Robert Haas <[email protected]>
0 siblings, 0 replies; 46+ 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] 46+ messages in thread
* [PATCH v24 5/7] fixups.patch
@ 2021-02-10 21:56 Robert Haas <[email protected]>
0 siblings, 0 replies; 46+ 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] 46+ messages in thread
* [PATCH v24 05/10] fixups.patch
@ 2021-02-10 21:56 Robert Haas <[email protected]>
0 siblings, 0 replies; 46+ 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] 46+ messages in thread
* postgres_fdw could deparse ArrayCoerceExpr
@ 2024-11-28 14:57 Alexander Pyhalov <[email protected]>
0 siblings, 0 replies; 46+ messages in thread
From: Alexander Pyhalov @ 2024-11-28 14:57 UTC (permalink / raw)
To: [email protected]
Hi.
Recently, we were surprised by the following behavior - prepared
statement, selecting data from foreign table with varchar(N) field
couldn't push down "field = ANY($1)" expression, when switched to
generic plan. This looked like shown in the attached patch. Reproducer
is simple:
create extension postgres_fdw;
create server local foreign data wrapper postgres_fdw;
create user MAPPING FOR CURRENT_USER SERVER local;
create table test (c varchar(255));
create foreign table ftest (c varchar(255)) server local options
(table_name 'test');
set plan_cache_mode to force_generic_plan ; -- just for demonstration,
can happen with defautl plan_cache_mode, if planner decides that generic
plan is preferable
prepare s(varchar[]) as select * from ftest where c = any ($1);
explain verbose execute s('{test}');
QUERY PLAN
----------------------------------------------------------------------
Foreign Scan on public.ftest (cost=100.00..143.43 rows=7 width=516)
Output: c
Filter: ((ftest.c)::text = ANY (($1)::text[]))
Remote SQL: SELECT c FROM public.test
The issue is that we need to translate input array type from varchar[]
to text[].
Attaching patch to allow postgres_fdw to deparse such conversion.
--
Best regards,
Alexander Pyhalov,
Postgres Professional
Attachments:
[text/x-diff] v1-0001-postgres_fdw-could-deparse-ArrayCoerceExpr.patch (5.3K, ../../[email protected]/2-v1-0001-postgres_fdw-could-deparse-ArrayCoerceExpr.patch)
download | inline diff:
From efc5eb338db6621243e25e0b0281ae69c465974d Mon Sep 17 00:00:00 2001
From: Alexander Pyhalov <[email protected]>
Date: Wed, 27 Nov 2024 14:07:39 +0300
Subject: [PATCH] postgres_fdw could deparse ArrayCoerceExpr
---
contrib/postgres_fdw/deparse.c | 50 +++++++++++++++++++
.../postgres_fdw/expected/postgres_fdw.out | 21 ++++++++
contrib/postgres_fdw/sql/postgres_fdw.sql | 9 ++++
3 files changed, 80 insertions(+)
diff --git a/contrib/postgres_fdw/deparse.c b/contrib/postgres_fdw/deparse.c
index 4680d517331..008237cb8f8 100644
--- a/contrib/postgres_fdw/deparse.c
+++ b/contrib/postgres_fdw/deparse.c
@@ -160,6 +160,7 @@ static void deparseDistinctExpr(DistinctExpr *node, deparse_expr_cxt *context);
static void deparseScalarArrayOpExpr(ScalarArrayOpExpr *node,
deparse_expr_cxt *context);
static void deparseRelabelType(RelabelType *node, deparse_expr_cxt *context);
+static void deparseArrayCoerceExpr(ArrayCoerceExpr *node, deparse_expr_cxt *context);
static void deparseBoolExpr(BoolExpr *node, deparse_expr_cxt *context);
static void deparseNullTest(NullTest *node, deparse_expr_cxt *context);
static void deparseCaseExpr(CaseExpr *node, deparse_expr_cxt *context);
@@ -696,6 +697,34 @@ foreign_expr_walker(Node *node,
state = FDW_COLLATE_UNSAFE;
}
break;
+ case T_ArrayCoerceExpr:
+ {
+ ArrayCoerceExpr *e = (ArrayCoerceExpr *) node;
+
+ /*
+ * Recurse to input subexpression.
+ */
+ if (!foreign_expr_walker((Node *) e->arg,
+ glob_cxt, &inner_cxt, case_arg_cxt))
+ return false;
+
+ /*
+ * T_ArrayCoerceExpr must not introduce a collation not
+ * derived from an input foreign Var (same logic as for a
+ * function).
+ */
+ collation = e->resultcollid;
+ if (collation == InvalidOid)
+ state = FDW_COLLATE_NONE;
+ else if (inner_cxt.state == FDW_COLLATE_SAFE &&
+ collation == inner_cxt.collation)
+ state = FDW_COLLATE_SAFE;
+ else if (collation == DEFAULT_COLLATION_OID)
+ state = FDW_COLLATE_NONE;
+ else
+ state = FDW_COLLATE_UNSAFE;
+ }
+ break;
case T_BoolExpr:
{
BoolExpr *b = (BoolExpr *) node;
@@ -2913,6 +2942,9 @@ deparseExpr(Expr *node, deparse_expr_cxt *context)
case T_RelabelType:
deparseRelabelType((RelabelType *) node, context);
break;
+ case T_ArrayCoerceExpr:
+ deparseArrayCoerceExpr((ArrayCoerceExpr *) node, context);
+ break;
case T_BoolExpr:
deparseBoolExpr((BoolExpr *) node, context);
break;
@@ -3501,6 +3533,24 @@ deparseRelabelType(RelabelType *node, deparse_expr_cxt *context)
node->resulttypmod));
}
+/*
+ * Deparse a ArrayCoerceExpr (array-type conversion) node.
+ */
+static void
+deparseArrayCoerceExpr(ArrayCoerceExpr *node, deparse_expr_cxt *context)
+{
+ deparseExpr(node->arg, context);
+
+ /*
+ * No difference how to deparse explicit cast, but if we omit implicit
+ * cast in the query, it'll be more user-friendly
+ */
+ if (node->coerceformat != COERCE_IMPLICIT_CAST)
+ appendStringInfo(context->buf, "::%s",
+ deparse_type_name(node->resulttype,
+ node->resulttypmod));
+}
+
/*
* Deparse a BoolExpr node.
*/
diff --git a/contrib/postgres_fdw/expected/postgres_fdw.out b/contrib/postgres_fdw/expected/postgres_fdw.out
index f2bcd6aa98c..55a8ac9020e 100644
--- a/contrib/postgres_fdw/expected/postgres_fdw.out
+++ b/contrib/postgres_fdw/expected/postgres_fdw.out
@@ -1169,6 +1169,27 @@ SELECT * FROM ft1 WHERE CASE c3 COLLATE "C" WHEN c6 THEN true ELSE c3 < 'bar' EN
Remote SQL: SELECT "C 1", c2, c3, c4, c5, c6, c7, c8 FROM "S 1"."T 1"
(4 rows)
+-- Test array type conversion pushdown
+SET plan_cache_mode = force_generic_plan;
+PREPARE s(varchar[]) AS SELECT count(*) FROM ft2 WHERE c6 = ANY ($1);
+EXPLAIN (VERBOSE, COSTS OFF)
+EXECUTE s(ARRAY['1','2']);
+ QUERY PLAN
+---------------------------------------------------------------------------------------------
+ Foreign Scan
+ Output: (count(*))
+ Relations: Aggregate on (public.ft2)
+ Remote SQL: SELECT count(*) FROM "S 1"."T 1" WHERE ((c6 = ANY ($1::character varying[])))
+(4 rows)
+
+EXECUTE s(ARRAY['1','2']);
+ count
+-------
+ 200
+(1 row)
+
+DEALLOCATE s;
+RESET plan_cache_mode;
-- a regconfig constant referring to this text search configuration
-- is initially unshippable
CREATE TEXT SEARCH CONFIGURATION public.custom_search
diff --git a/contrib/postgres_fdw/sql/postgres_fdw.sql b/contrib/postgres_fdw/sql/postgres_fdw.sql
index 372fe6dad15..164cd8b895a 100644
--- a/contrib/postgres_fdw/sql/postgres_fdw.sql
+++ b/contrib/postgres_fdw/sql/postgres_fdw.sql
@@ -450,6 +450,15 @@ SELECT * FROM ft1 WHERE CASE c3 WHEN c6 THEN true ELSE c3 < 'bar' END;
EXPLAIN (VERBOSE, COSTS OFF)
SELECT * FROM ft1 WHERE CASE c3 COLLATE "C" WHEN c6 THEN true ELSE c3 < 'bar' END;
+-- Test array type conversion pushdown
+SET plan_cache_mode = force_generic_plan;
+PREPARE s(varchar[]) AS SELECT count(*) FROM ft2 WHERE c6 = ANY ($1);
+EXPLAIN (VERBOSE, COSTS OFF)
+EXECUTE s(ARRAY['1','2']);
+EXECUTE s(ARRAY['1','2']);
+DEALLOCATE s;
+RESET plan_cache_mode;
+
-- a regconfig constant referring to this text search configuration
-- is initially unshippable
CREATE TEXT SEARCH CONFIGURATION public.custom_search
--
2.43.0
^ permalink raw reply [nested|flat] 46+ messages in thread
end of thread, other threads:[~2024-11-28 14:57 UTC | newest]
Thread overview: 46+ messages (download: mbox mbox.gz follow: Atom feed)
-- links below jump to the message on this page --
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 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 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 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 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 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 05/10] 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 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 5/7] fixups.patch Robert Haas <[email protected]>
2021-02-10 21:56 [PATCH v24 05/10] fixups.patch Robert Haas <[email protected]>
2024-11-28 14:57 postgres_fdw could deparse ArrayCoerceExpr Alexander Pyhalov <[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