Support splitting compressed chunks

Add support for splitting compressed chunks when calling
split_chunk(). Only 2-way splits are supported, as before.

When splitting a compressed chunk, the same rewrite-approach is taken
as when splitting a non-compressed chunk. The main difference is that
the internal compressed relation is split in a separate step, similar
to the non-compressed relation. One complication is that the split
might end up in the middle of a compressed segment, in which case the
segment needs to be split as well. This is done by decompressing the
segment in memory and creating two new segments that get written to
the resulting split relations. Since the non-compressed and compressed
relations are split separetely, the non-compressed data remains
non-compressed after the split.

Special care is also taken to handle compression stats. In particular,
instead of computing new stats, the existing stats are divided across
the result relations depending on the amount of data received. This
means that the sum of the stats after a split is the same as before
the split. Computing new stats is not feasible given that the current
approach requires knowing the pre-compressed relation sizes, which is
not possible without first decompressing everything.

Author: erimatnor

.unreleased/pr_8100

@@ -0,0 +1 @@
+Implements: #8100 Support splitting compressed chunks

src/chunk.c

@@ -711,11 +711,18 @@ copy_hypertable_acl_to_relid(const Hypertable *ht, const Oid owner_id, const Oid
  * instead needs the proper permissions on the database to create the schema.
  */
 Oid
-ts_chunk_create_table(const Chunk *chunk, const Hypertable *ht, const char *tablespacename)
+ts_chunk_create_table(const Chunk *chunk, const Hypertable *ht, const char *tablespacename,
+					  Oid amoid)
 {
 	Relation rel;
 	ObjectAddress address;
 	int sec_ctx;
+	char *amname = NULL;
+
+	if (OidIsValid(amoid))
+		amname = get_am_name(amoid);
+	else if (chunk->relkind == RELKIND_RELATION)
+		amname = get_am_name(ts_get_rel_am(chunk->hypertable_relid));
 
 	/*
 	 * CreateStmt node to create the chunk table
@@ -731,9 +738,7 @@ ts_chunk_create_table(const Chunk *chunk, const Hypertable *ht, const char *tabl
 		.tablespacename = tablespacename ? (char *) tablespacename : NULL,
 		.options =
 			(chunk->relkind == RELKIND_RELATION) ? ts_get_reloptions(ht->main_table_relid) : NIL,
-		.accessMethod = (chunk->relkind == RELKIND_RELATION) ?
-							get_am_name(ts_get_rel_am(chunk->hypertable_relid)) :
-							NULL,
+		.accessMethod = amname,
 	};
 	Oid uid, saved_uid;
 
@@ -950,12 +955,12 @@ chunk_create_table_constraints(const Hypertable *ht, const Chunk *chunk)
 }
 
 static Oid
-chunk_create_table(Chunk *chunk, const Hypertable *ht)
+chunk_create_table(Chunk *chunk, const Hypertable *ht, Oid amoid)
 {
 	/* Create the actual table relation for the chunk */
 	const char *tablespace = ts_hypertable_select_tablespace_name(ht, chunk);
 
-	chunk->table_id = ts_chunk_create_table(chunk, ht, tablespace);
+	chunk->table_id = ts_chunk_create_table(chunk, ht, tablespace, amoid);
 
 	Assert(OidIsValid(chunk->table_id));
 
@@ -968,7 +973,8 @@ chunk_create_table(Chunk *chunk, const Hypertable *ht)
  */
 static Chunk *
 chunk_create_only_table_after_lock(const Hypertable *ht, Hypercube *cube, const char *schema_name,
-								   const char *table_name, const char *prefix, int32 chunk_id)
+								   const char *table_name, const char *prefix, Oid amoid,
+								   int32 chunk_id)
 {
 	Chunk *chunk;
 
@@ -977,15 +983,15 @@ chunk_create_only_table_after_lock(const Hypertable *ht, Hypercube *cube, const
 	chunk = chunk_create_object(ht, cube, schema_name, table_name, prefix, chunk_id);
 	Assert(chunk != NULL);
 
-	chunk_create_table(chunk, ht);
+	chunk_create_table(chunk, ht, amoid);
 
 	return chunk;
 }
 
 static Chunk *
 chunk_create_from_hypercube_after_lock(const Hypertable *ht, Hypercube *cube,
 									   const char *schema_name, const char *table_name,
-									   const char *prefix)
+									   const char *prefix, Oid amoid)
 {
 	chunk_insert_check_hook_type osm_chunk_insert_hook = ts_get_osm_chunk_insert_hook();
 
@@ -1033,6 +1039,7 @@ chunk_create_from_hypercube_after_lock(const Hypertable *ht, Hypercube *cube,
 													  schema_name,
 													  table_name,
 													  prefix,
+													  amoid,
 													  get_next_chunk_id());
 
 	/* Insert any new chunk column stats entries into the catalog */
@@ -1083,7 +1090,8 @@ chunk_add_inheritance(Chunk *chunk, const Hypertable *ht)
 static Chunk *
 chunk_create_from_hypercube_and_table_after_lock(const Hypertable *ht, Hypercube *cube,
 												 Oid chunk_table_relid, const char *schema_name,
-												 const char *table_name, const char *prefix)
+												 const char *table_name, const char *prefix,
+												 Oid amoid)
 {
 	Oid current_chunk_schemaid = get_rel_namespace(chunk_table_relid);
 	Oid new_chunk_schemaid = InvalidOid;
@@ -1172,12 +1180,18 @@ chunk_create_from_point_after_lock(const Hypertable *ht, const Point *p, const c
 	/* Resolve collisions with other chunks by cutting the new hypercube */
 	chunk_collision_resolve(ht, cube, p);
 
-	return chunk_create_from_hypercube_after_lock(ht, cube, schema_name, table_name, prefix);
+	return chunk_create_from_hypercube_after_lock(ht,
+												  cube,
+												  schema_name,
+												  table_name,
+												  prefix,
+												  InvalidOid);
 }
 
 Chunk *
 ts_chunk_find_or_create_without_cuts(const Hypertable *ht, Hypercube *hc, const char *schema_name,
-									 const char *table_name, Oid chunk_table_relid, bool *created)
+									 const char *table_name, Oid chunk_table_relid, Oid amoid,
+									 bool *created)
 {
 	ChunkStub *stub;
 	Chunk *chunk = NULL;
@@ -1211,10 +1225,15 @@ ts_chunk_find_or_create_without_cuts(const Hypertable *ht, Hypercube *hc, const
 																		 chunk_table_relid,
 																		 schema_name,
 																		 table_name,
-																		 NULL);
+																		 NULL,
+																		 amoid);
 			else
-				chunk =
-					chunk_create_from_hypercube_after_lock(ht, hc, schema_name, table_name, NULL);
+				chunk = chunk_create_from_hypercube_after_lock(ht,
+															   hc,
+															   schema_name,
+															   table_name,
+															   NULL,
+															   amoid);
 
 			if (NULL != created)
 				*created = true;
@@ -1812,7 +1831,7 @@ chunk_resurrect(const Hypertable *ht, int chunk_id)
 		/* Create data table and related objects */
 		chunk->hypertable_relid = ht->main_table_relid;
 		chunk->relkind = RELKIND_RELATION;
-		chunk->table_id = chunk_create_table(chunk, ht);
+		chunk->table_id = chunk_create_table(chunk, ht, InvalidOid);
 		chunk_create_table_constraints(ht, chunk);
 
 		/* Finally, update the chunk tuple to no longer be a tombstone */

src/chunk.h

@@ -171,7 +171,7 @@ extern TSDLLEXPORT Chunk *ts_chunk_get_by_name_with_memory_context(const char *s
 extern TSDLLEXPORT void ts_chunk_insert_lock(const Chunk *chunk, LOCKMODE lock);
 
 extern TSDLLEXPORT Oid ts_chunk_create_table(const Chunk *chunk, const Hypertable *ht,
-											 const char *tablespacename);
+											 const char *tablespacename, Oid amoid);
 extern TSDLLEXPORT Chunk *ts_chunk_get_by_id(int32 id, bool fail_if_not_found);
 extern TSDLLEXPORT Chunk *ts_chunk_get_by_relid(Oid relid, bool fail_if_not_found);
 extern TSDLLEXPORT void ts_chunk_free(Chunk *chunk);
@@ -212,9 +212,11 @@ extern TSDLLEXPORT void ts_chunk_drop_preserve_catalog_row(const Chunk *chunk,
 extern TSDLLEXPORT List *ts_chunk_do_drop_chunks(Hypertable *ht, int64 older_than, int64 newer_than,
 												 int32 log_level, Oid time_type, Oid arg_type,
 												 bool older_newer);
-extern TSDLLEXPORT Chunk *
-ts_chunk_find_or_create_without_cuts(const Hypertable *ht, Hypercube *hc, const char *schema_name,
-									 const char *table_name, Oid chunk_table_relid, bool *created);
+extern TSDLLEXPORT Chunk *ts_chunk_find_or_create_without_cuts(const Hypertable *ht, Hypercube *hc,
+															   const char *schema_name,
+															   const char *table_name,
+															   Oid chunk_table_relid, Oid amoid,
+															   bool *created);
 extern TSDLLEXPORT Chunk *ts_chunk_get_compressed_chunk_parent(const Chunk *chunk);
 extern TSDLLEXPORT bool ts_chunk_is_unordered(const Chunk *chunk);
 extern TSDLLEXPORT bool ts_chunk_is_partial(const Chunk *chunk);