Use DELETE after compression

The last step of compressing chunk is cleanup the uncompressed chunk and
currently it is done by a `TRUNCATE` that requires an
`AccessExclusiveLock` preventing concurrent sessions even `SELECT` data
from the hypertable.

With this PR will be possible to execute a `DELETE` instead of a
`TRUNCATE` on the uncompressed chunk relaxing the lock to
`RowExclusiveLock`. This new behavior is controled by a new GUC
`timescaledb.enable_delete_after_compression` that is `false` by
default.

The side effect of enabling this behavior will be more WAL generation
because we'll delete each row from uncompressed chunk and also bloat due
to a lot of dead tuples created.

Author: fabriziomello

.unreleased/pr_7116

@@ -0,0 +1 @@
+Implements: #7116 Use DELETE instead of TRUNCATE after compression

src/guc.c

@@ -85,6 +85,7 @@ static char *ts_guc_default_segmentby_fn = NULL;
 static char *ts_guc_default_orderby_fn = NULL;
 TSDLLEXPORT bool ts_guc_enable_job_execution_logging = false;
 bool ts_guc_enable_tss_callbacks = true;
+TSDLLEXPORT bool ts_guc_enable_delete_after_compression = false;
 
 /* default value of ts_guc_max_open_chunks_per_insert and ts_guc_max_cached_chunks_per_hypertable
  * will be set as their respective boot-value when the GUC mechanism starts up */
@@ -685,6 +686,17 @@ _guc_init(void)
 							 NULL,
 							 NULL);
 
+	DefineCustomBoolVariable(MAKE_EXTOPTION("enable_delete_after_compression"),
+							 "Delete all rows after compression instead of truncate",
+							 "Delete all rows after compression instead of truncate",
+							 &ts_guc_enable_delete_after_compression,
+							 false,
+							 PGC_USERSET,
+							 0,
+							 NULL,
+							 NULL,
+							 NULL);
+
 #ifdef USE_TELEMETRY
 	DefineCustomEnumVariable(MAKE_EXTOPTION("telemetry_level"),
 							 "Telemetry settings level",

src/guc.h

@@ -42,6 +42,7 @@ extern int ts_guc_max_open_chunks_per_insert;
 extern int ts_guc_max_cached_chunks_per_hypertable;
 extern TSDLLEXPORT bool ts_guc_enable_job_execution_logging;
 extern bool ts_guc_enable_tss_callbacks;
+extern TSDLLEXPORT bool ts_guc_enable_delete_after_compression;
 
 #ifdef USE_TELEMETRY
 typedef enum TelemetryLevel

tsl/src/compression/compression.c

@@ -161,6 +161,46 @@ truncate_relation(Oid table_oid)
 	table_close(rel, NoLock);
 }
 
+/* Handle the all rows deletion of a given relation */
+static void
+RelationDeleteAllRows(Relation rel, Snapshot snap)
+{
+	TupleTableSlot *slot = table_slot_create(rel, NULL);
+	TableScanDesc scan = table_beginscan(rel, snap, 0, (ScanKey) NULL);
+
+	while (table_scan_getnextslot(scan, ForwardScanDirection, slot))
+	{
+		simple_table_tuple_delete(rel, &(slot->tts_tid), snap);
+	}
+	table_endscan(scan);
+	ExecDropSingleTupleTableSlot(slot);
+}
+
+/*
+ * Delete the relation WITHOUT applying triggers. This will be used when
+ * `enable_delete_after_compression = true` instead of truncating the relation.
+ * Also don't restart sequences.
+ */
+static void
+delete_relation_rows(Oid table_oid)
+{
+	Relation rel = table_open(table_oid, RowExclusiveLock);
+	Snapshot snap = GetLatestSnapshot();
+
+	/* Delete the rows in the table */
+	RelationDeleteAllRows(rel, snap);
+
+	/* Delete the rows in the toast table */
+	if (OidIsValid(rel->rd_rel->reltoastrelid))
+	{
+		Relation toast_rel = table_open(rel->rd_rel->reltoastrelid, RowExclusiveLock);
+		RelationDeleteAllRows(toast_rel, snap);
+		table_close(toast_rel, NoLock);
+	}
+
+	table_close(rel, NoLock);
+}
+
 /*
  * Use reltuples as an estimate for the number of rows that will get compressed. This value
  * might be way off the mark in case analyze hasn't happened in quite a while on this input
@@ -191,7 +231,7 @@ compress_chunk(Oid in_table, Oid out_table, int insert_options)
 {
 	int n_keys;
 	ListCell *lc;
-	int indexscan_direction = NoMovementScanDirection;
+	ScanDirection indexscan_direction = NoMovementScanDirection;
 	Relation matched_index_rel = NULL;
 	TupleTableSlot *slot;
 	IndexScanDesc index_scan;
@@ -456,8 +496,17 @@ compress_chunk(Oid in_table, Oid out_table, int insert_options)
 	}
 
 	row_compressor_close(&row_compressor);
-	DEBUG_WAITPOINT("compression_done_before_truncate_uncompressed");
-	truncate_relation(in_table);
+	if (!ts_guc_enable_delete_after_compression)
+	{
+		DEBUG_WAITPOINT("compression_done_before_truncate_uncompressed");
+		truncate_relation(in_table);
+		DEBUG_WAITPOINT("compression_done_after_truncate_uncompressed");
+	}
+	else
+	{
+		delete_relation_rows(in_table);
+		DEBUG_WAITPOINT("compression_done_after_delete_uncompressed");
+	}
 
 	table_close(out_rel, NoLock);
 	table_close(in_rel, NoLock);

tsl/test/expected/compression.out

@@ -2874,3 +2874,58 @@ SELECT compress_chunk(ch) FROM show_chunks('hyper_84') ch;
 
 -- indexscan for decompression: DELETE
 DELETE FROM hyper_84 WHERE device = 1;
+-- Test using DELETE instead of TRUNCATE after compression
+CREATE TABLE hyper_delete (time timestamptz, device int, location int, temp float, t text);
+SELECT table_name FROM create_hypertable('hyper_delete', 'time');
+NOTICE:  adding not-null constraint to column "time"
+  table_name  
+--------------
+ hyper_delete
+(1 row)
+
+INSERT INTO hyper_delete VALUES ('2024-07-10', 1, 1, 1.0, repeat('X', 10000));
+ANALYZE hyper_delete;
+SELECT ch AS "CHUNK" FROM show_chunks('hyper_delete') ch \gset
+SELECT relpages, reltuples::int AS reltuples FROM pg_catalog.pg_class WHERE oid = :'CHUNK'::regclass;
+ relpages | reltuples 
+----------+-----------
+        1 |         1
+(1 row)
+
+-- One uncompressed row
+SELECT count(*) FROM :CHUNK;
+ count 
+-------
+     1
+(1 row)
+
+ALTER TABLE hyper_delete SET (timescaledb.compress, timescaledb.compress_segmentby='device');
+NOTICE:  default order by for hypertable "hyper_delete" is set to ""time" DESC"
+SET timescaledb.enable_delete_after_compression TO true;
+SELECT FROM compress_chunk(:'CHUNK');
+--
+(1 row)
+
+-- still have more than one tuple
+SELECT relpages, reltuples::int AS reltuples FROM pg_catalog.pg_class WHERE oid = :'CHUNK'::regclass;
+ relpages | reltuples 
+----------+-----------
+        1 |         1
+(1 row)
+
+ANALYZE hyper_delete;
+-- after ANALYZE we should have no tuples
+SELECT relpages, reltuples::int AS reltuples FROM pg_catalog.pg_class WHERE oid = :'CHUNK'::regclass;
+ relpages | reltuples 
+----------+-----------
+        1 |         0
+(1 row)
+
+-- One compressed row
+SELECT count(*) FROM :CHUNK;
+ count 
+-------
+     1
+(1 row)
+
+RESET timescaledb.enable_delete_after_compression;