Refactor function hypertable_local_size

Reorganize the code and fix minor bug that was not computing the size
of FSM, VM and INIT forks of the parent hypertable.

Fixed the bug by exposing the `ts_relation_size` function to the SQL
level to encapsulate the logic to compute `heap`, `indexes` and `toast`
sizes.

sql/size_utils.sql

@@ -5,55 +5,65 @@
 -- This file contains utility functions to get the relation size
 -- of hypertables, chunks, and indexes on hypertables.
 
-CREATE OR REPLACE VIEW _timescaledb_internal.hypertable_chunk_local_size AS 
+CREATE OR REPLACE FUNCTION _timescaledb_internal.relation_size(relation REGCLASS)
-SELECT *, 
+RETURNS TABLE (total_size BIGINT, heap_size BIGINT, index_size BIGINT, toast_size BIGINT)
-   compressed_total_size - COALESCE(compressed_index_size, 0) - COALESCE(compressed_toast_size, 0) as compressed_heap_size
+AS '@MODULE_PATHNAME@', 'ts_relation_size' LANGUAGE C VOLATILE;
+
+CREATE OR REPLACE VIEW _timescaledb_internal.hypertable_chunk_local_size AS
+WITH chunks AS (
+    SELECT
+        h.schema_name AS hypertable_schema,
+        h.table_name AS hypertable_name,
+        h.id AS hypertable_id,
+        c.id AS chunk_id,
+        c.schema_name AS chunk_schema,
+        c.table_name AS chunk_name,
+        format('%I.%I', c.schema_name, c.table_name)::regclass AS relid,
+        CASE WHEN comp.schema_name IS NOT NULL AND comp.table_name IS NOT NULL THEN
+            format('%I.%I', comp.schema_name, comp.table_name)::regclass
+        ELSE
+            NULL::regclass
+        END AS relidcomp,
+        c.compressed_chunk_id
+    FROM
+        _timescaledb_catalog.hypertable h
+        JOIN _timescaledb_catalog.chunk c ON h.id = c.hypertable_id
+            AND c.dropped IS FALSE
+        LEFT JOIN _timescaledb_catalog.chunk comp ON comp.id = c.compressed_chunk_id
+),
+sizes AS (
+    SELECT
+        ch.hypertable_schema,
+        ch.hypertable_name,
+        ch.hypertable_id,
+        ch.chunk_id,
+        ch.chunk_schema,
+        ch.chunk_name,
+        _timescaledb_internal.relation_size(ch.relid) AS relsize,
+        _timescaledb_internal.relation_size(ch.relidcomp) AS relcompsize
+    FROM
+        chunks ch
+)
+SELECT
+    hypertable_schema,
+    hypertable_name,
+    hypertable_id,
+    chunk_id,
+    chunk_schema,
+    chunk_name,
+    COALESCE((relsize).total_size, 0) AS total_bytes,
+    COALESCE((relsize).heap_size, 0) AS heap_bytes,
+    COALESCE((relsize).index_size, 0) AS index_bytes,
+    COALESCE((relsize).toast_size, 0) AS toast_bytes,
+    COALESCE((relcompsize).total_size, 0) AS compressed_total_size,
+    COALESCE((relcompsize).heap_size, 0) AS compressed_heap_size,
+    COALESCE((relcompsize).index_size, 0) AS compressed_index_size,
+    COALESCE((relcompsize).toast_size, 0) AS compressed_toast_size
 FROM
-( SELECT
+    sizes;
-   h.schema_name AS hypertable_schema,
-   h.table_name AS hypertable_name,
-   h.id as hypertable_id,
-   c.id as chunk_id,
-   c.schema_name as chunk_schema,
-   c.table_name as chunk_name,
-   pg_total_relation_size(format('%I.%I', c.schema_name, c.table_name))::bigint AS total_bytes,
-   pg_indexes_size(format('%I.%I', c.schema_name, c.table_name))::bigint AS index_bytes,
-   pg_total_relation_size(pgc.reltoastrelid)::bigint AS toast_bytes,
-   CASE WHEN map.table_name IS NOT NULL 
-        THEN pg_total_relation_size(format('%I.%I', map.schema_name, map.table_name))::bigint 
-        ELSE 0
-   END AS compressed_total_size,
-   CASE WHEN map.table_name IS NOT NULL 
-        THEN pg_indexes_size(format('%I.%I', map.schema_name, map.table_name))::bigint 
-        ELSE 0
-   END AS compressed_index_size,
-   CASE WHEN map.reltoastrelid IS NOT NULL 
-        THEN pg_total_relation_size(map.reltoastrelid)::bigint 
-        ELSE 0
-   END AS compressed_toast_size
-FROM
-   _timescaledb_catalog.hypertable h 
-   INNER JOIN
-      _timescaledb_catalog.chunk c 
-      ON h.id = c.hypertable_id 
-      and c.dropped = false 
-   INNER JOIN
-      pg_class pgc 
-      ON pgc.relname = c.table_name 
-   INNER JOIN
-      pg_namespace pns 
-      ON pns.oid = pgc.relnamespace 
-      AND pns.nspname = c.schema_name 
-   LEFT OUTER JOIN
-      ( SELECT comp.id, comp.schema_name, comp.table_name, reltoastrelid
-        FROM _timescaledb_catalog.chunk comp, pg_class, pg_namespace
-        WHERE comp.table_name = pg_class.relname
-        AND comp.schema_name = pg_namespace.nspname
-        AND pg_namespace.oid = pg_class.relnamespace ) map
-  ON map.id = c.compressed_chunk_id ) subq;
 
 GRANT SELECT ON  _timescaledb_internal.hypertable_chunk_local_size TO PUBLIC;
- 
+
 CREATE OR REPLACE FUNCTION _timescaledb_internal.data_node_hypertable_info(
     node_name              NAME,
     schema_name_in name,
@@ -85,22 +95,64 @@ CREATE OR REPLACE FUNCTION _timescaledb_internal.hypertable_local_size(
 	schema_name_in name,
 	table_name_in name)
 RETURNS TABLE (
-	table_bytes bigint,
+	table_bytes BIGINT,
-	index_bytes bigint,
+	index_bytes BIGINT,
-	toast_bytes bigint,
+	toast_bytes BIGINT,
-	total_bytes bigint)
+	total_bytes BIGINT)
 LANGUAGE SQL VOLATILE STRICT AS
 $BODY$
+    /* get the main hypertable id and sizes */
+    WITH _hypertable AS (
+        SELECT
+            id,
+            _timescaledb_internal.relation_size(format('%I.%I', schema_name, table_name)::regclass) AS relsize
+        FROM
+            _timescaledb_catalog.hypertable
+        WHERE
+            schema_name = schema_name_in
+            AND table_name = table_name_in
+    ),
+    /* project the size of the parent hypertable */
+    _hypertable_sizes AS (
+        SELECT
+            id,
+            COALESCE((relsize).total_size, 0) AS total_bytes,
+            COALESCE((relsize).heap_size, 0) AS heap_bytes,
+            COALESCE((relsize).index_size, 0) AS index_bytes,
+            COALESCE((relsize).toast_size, 0) AS toast_bytes,
+            0::BIGINT AS compressed_total_size,
+            0::BIGINT AS compressed_index_size,
+            0::BIGINT AS compressed_toast_size,
+            0::BIGINT AS compressed_heap_size
+        FROM
+            _hypertable
+    ),
+    /* calculate the size of the hypertable chunks */
+    _chunk_sizes AS (
+        SELECT
+            chunk_id,
+            COALESCE(ch.total_bytes, 0) AS total_bytes,
+            COALESCE(ch.heap_bytes, 0) AS heap_bytes,
+            COALESCE(ch.index_bytes, 0) AS index_bytes,
+            COALESCE(ch.toast_bytes, 0) AS toast_bytes,
+            COALESCE(ch.compressed_total_size, 0) AS compressed_total_size,
+            COALESCE(ch.compressed_index_size, 0) AS compressed_index_size,
+            COALESCE(ch.compressed_toast_size, 0) AS compressed_toast_size,
+            COALESCE(ch.compressed_heap_size, 0) AS compressed_heap_size
+        FROM
+            _timescaledb_internal.hypertable_chunk_local_size ch
+            JOIN _hypertable_sizes ht ON ht.id = ch.hypertable_id
+    )
+    /* calculate the SUM of the hypertable and chunk sizes */
 	SELECT
-		(COALESCE(sum(ch.total_bytes), 0) - COALESCE(sum(ch.index_bytes), 0) - COALESCE(sum(ch.toast_bytes), 0) + COALESCE(sum(ch.compressed_heap_size), 0))::bigint + pg_relation_size(format('%I.%I', schema_name_in, table_name_in)::regclass)::bigint AS heap_bytes,
+		(SUM(heap_bytes)  + SUM(compressed_heap_size))::BIGINT AS heap_bytes,
-		(COALESCE(sum(ch.index_bytes), 0) + COALESCE(sum(ch.compressed_index_size), 0))::bigint + pg_indexes_size(format('%I.%I', schema_name_in, table_name_in)::regclass)::bigint AS index_bytes,
+		(SUM(index_bytes) + SUM(compressed_index_size))::BIGINT AS index_bytes,
-		(COALESCE(sum(ch.toast_bytes), 0) + COALESCE(sum(ch.compressed_toast_size), 0))::bigint AS toast_bytes,
+		(SUM(toast_bytes) + SUM(compressed_toast_size))::BIGINT AS toast_bytes,
-		(COALESCE(sum(ch.total_bytes), 0) + COALESCE(sum(ch.compressed_total_size), 0))::bigint + pg_total_relation_size(format('%I.%I', schema_name_in, table_name_in)::regclass)::bigint AS total_bytes
+		(SUM(total_bytes) + SUM(compressed_total_size))::BIGINT AS total_bytes
 	FROM
-		_timescaledb_internal.hypertable_chunk_local_size ch
+		(SELECT * FROM _hypertable_sizes
-	WHERE
+         UNION ALL
-		hypertable_schema = schema_name_in
+         SELECT * FROM _chunk_sizes) AS sizes;
-		AND hypertable_name = table_name_in
 $BODY$ SET search_path TO pg_catalog;
 
 CREATE OR REPLACE FUNCTION _timescaledb_internal.hypertable_remote_size(
@@ -190,7 +242,7 @@ $BODY$ SET search_path TO pg_catalog;
 --- returns total-bytes for a hypertable (includes table + index)
 CREATE OR REPLACE FUNCTION @extschema@.hypertable_size(
     hypertable              REGCLASS)
-RETURNS BIGINT 
+RETURNS BIGINT
 LANGUAGE SQL VOLATILE STRICT AS
 $BODY$
    -- One row per data node is returned (in case of a distributed
@@ -219,7 +271,7 @@ $BODY$
       (ch.total_bytes - COALESCE( ch.index_bytes , 0 ) - COALESCE( ch.toast_bytes, 0 ) + COALESCE( ch.compressed_heap_size , 0 ))::bigint  as heap_bytes,
       (COALESCE( ch.index_bytes, 0 ) + COALESCE( ch.compressed_index_size , 0) )::bigint as index_bytes,
       (COALESCE( ch.toast_bytes, 0 ) + COALESCE( ch.compressed_toast_size, 0 ))::bigint as toast_bytes,
-      (ch.total_bytes + COALESCE( ch.compressed_total_size, 0 ))::bigint as total_bytes 
+      (ch.total_bytes + COALESCE( ch.compressed_total_size, 0 ))::bigint as total_bytes
    FROM
 	  _timescaledb_internal.hypertable_chunk_local_size ch
    WHERE
@@ -274,7 +326,7 @@ $BODY$ SET search_path TO pg_catalog;
 -- Returns:
 -- chunk_schema                  - schema name for chunk
 -- chunk_name                    - chunk table name
--- table_bytes                   - Disk space used by chunk table 
+-- table_bytes                   - Disk space used by chunk table
 -- index_bytes                   - Disk space used by indexes
 -- toast_bytes                   - Disk space of toast tables
 -- total_bytes                   - Disk space used in total
@@ -310,12 +362,12 @@ BEGIN
 		END IF;
 
         CASE WHEN is_distributed THEN
-            RETURN QUERY SELECT ch.chunk_schema, ch.chunk_name, ch.table_bytes, ch.index_bytes, 
+            RETURN QUERY SELECT ch.chunk_schema, ch.chunk_name, ch.table_bytes, ch.index_bytes,
-                        ch.toast_bytes, ch.total_bytes, ch.node_name   
+                        ch.toast_bytes, ch.total_bytes, ch.node_name
             FROM _timescaledb_internal.chunks_remote_size(schema_name, table_name) ch;
         ELSE
-            RETURN QUERY SELECT chl.chunk_schema, chl.chunk_name, chl.table_bytes, chl.index_bytes, 
+            RETURN QUERY SELECT chl.chunk_schema, chl.chunk_name, chl.table_bytes, chl.index_bytes,
-                        chl.toast_bytes, chl.total_bytes, NULL::NAME   
+                        chl.toast_bytes, chl.total_bytes, NULL::NAME
             FROM _timescaledb_internal.chunks_local_size(schema_name, table_name) chl;
         END CASE;
 END;
@@ -569,7 +621,7 @@ CREATE OR REPLACE FUNCTION @extschema@.hypertable_compression_stats (hypertable
         node_name name)
     LANGUAGE SQL
     STABLE STRICT
-    AS	
+    AS
 $BODY$
 	SELECT
         count(*)::bigint AS total_chunks,
@@ -599,13 +651,13 @@ CREATE OR REPLACE FUNCTION _timescaledb_internal.indexes_local_size(
     index_name_in              NAME
 )
 RETURNS TABLE ( hypertable_id INTEGER,
-                total_bytes BIGINT ) 
+                total_bytes BIGINT )
 LANGUAGE SQL VOLATILE STRICT AS
 $BODY$
     WITH chunk_index_size (num_bytes) AS (
         SELECT
 		    COALESCE(sum(pg_relation_size(c.oid)), 0)::bigint
-        FROM                                      
+        FROM
             pg_class c,
             pg_namespace n,
             _timescaledb_catalog.chunk ch,
@@ -616,7 +668,7 @@ $BODY$
              AND c.relname = ci.index_name
              AND ch.id = ci.chunk_id
              AND h.id = ci.hypertable_id
-             AND h.schema_name = schema_name_in 
+             AND h.schema_name = schema_name_in
              AND ci.hypertable_index_name = index_name_in
     ) SELECT
 	      h.id,

sql/updates/latest-dev.sql

@@ -0,0 +1,5 @@
+CREATE FUNCTION _timescaledb_internal.relation_size(relation REGCLASS)
+RETURNS TABLE (total_size BIGINT, heap_size BIGINT, index_size BIGINT, toast_size BIGINT)
+AS '@MODULE_PATHNAME@', 'ts_relation_size' LANGUAGE C VOLATILE;
+
+DROP VIEW IF EXISTS _timescaledb_internal.hypertable_chunk_local_size;

sql/updates/reverse-dev.sql

@@ -0,0 +1,2 @@
+DROP VIEW _timescaledb_internal.hypertable_chunk_local_size;
+DROP FUNCTION _timescaledb_internal.relation_size(relation REGCLASS);

src/telemetry/stats.c

@@ -204,7 +204,8 @@ add_storage(StorageStats *stats, Form_pg_class class)
 {
 	RelationSize relsize;
 
-	relsize = ts_relation_size(class->oid);
+	relsize = ts_relation_size_impl(class->oid);
+	stats->relsize.total_size += relsize.total_size;
 	stats->relsize.heap_size += relsize.heap_size;
 	stats->relsize.toast_size += relsize.toast_size;
 	stats->relsize.index_size += relsize.index_size;

src/utils.c

@@ -904,19 +904,56 @@ ts_subtract_integer_from_now(PG_FUNCTION_ARGS)
 	return Int64GetDatum(res);
 }
 
-RelationSize
+TS_FUNCTION_INFO_V1(ts_relation_size);
-ts_relation_size(Oid relid)
+Datum
+ts_relation_size(PG_FUNCTION_ARGS)
 {
-	int64 tot_size;
+	Oid relid = PG_ARGISNULL(0) ? InvalidOid : PG_GETARG_OID(0);
-	RelationSize relsize;
+	RelationSize relsize = { 0 };
+	TupleDesc tupdesc;
+	HeapTuple tuple;
+	Datum values[4] = { 0 };
+	bool nulls[4] = { false };
+
+	/* Build a tuple descriptor for our result type */
+	if (get_call_result_type(fcinfo, NULL, &tupdesc) != TYPEFUNC_COMPOSITE)
+		ereport(ERROR,
+				(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
+				 errmsg("function returning record called in context "
+						"that cannot accept type record")));
+
+	if (!OidIsValid(relid))
+		PG_RETURN_NULL();
+
+	relsize = ts_relation_size_impl(relid);
+
+	tupdesc = BlessTupleDesc(tupdesc);
+
+	values[0] = Int64GetDatum(relsize.total_size);
+	values[1] = Int64GetDatum(relsize.heap_size);
+	values[2] = Int64GetDatum(relsize.index_size);
+	values[3] = Int64GetDatum(relsize.toast_size);
+
+	tuple = heap_form_tuple(tupdesc, values, nulls);
+
+	return HeapTupleGetDatum(tuple);
+}
+
+RelationSize
+ts_relation_size_impl(Oid relid)
+{
+	RelationSize relsize = { 0 };
 	Datum reloid = ObjectIdGetDatum(relid);
 	Relation rel;
 
 	/* Open relation earlier to keep a lock during all function calls */
 	rel = try_relation_open(relid, AccessShareLock);
 
+	if (!rel)
+		return relsize;
+
 	/* Get to total relation size to be our calculation base */
-	tot_size = DatumGetInt64(DirectFunctionCall1(pg_total_relation_size, reloid));
+	relsize.total_size = DatumGetInt64(DirectFunctionCall1(pg_total_relation_size, reloid));
 
 	/* Get the indexes size of the relation (don't consider TOAST indexes) */
 	relsize.index_size = DatumGetInt64(DirectFunctionCall1(pg_indexes_size, reloid));
@@ -932,7 +969,7 @@ ts_relation_size(Oid relid)
 	relation_close(rel, AccessShareLock);
 
 	/* Calculate the HEAP size based on the total size and indexes plus toast */
-	relsize.heap_size = tot_size - (relsize.index_size + relsize.toast_size);
+	relsize.heap_size = relsize.total_size - (relsize.index_size + relsize.toast_size);
 
 	return relsize;
 }

src/utils.h

@@ -186,12 +186,13 @@ TryRegisterCustomScanMethods(const CustomScanMethods *methods)
 
 typedef struct RelationSize
 {
+	int64 total_size;
 	int64 heap_size;
 	int64 toast_size;
 	int64 index_size;
 } RelationSize;
 
-extern TSDLLEXPORT RelationSize ts_relation_size(Oid relid);
+extern TSDLLEXPORT RelationSize ts_relation_size_impl(Oid relid);
 
 extern TSDLLEXPORT const char *ts_get_node_name(Node *node);
 

test/expected/relocate_extension.out

@@ -160,7 +160,7 @@ SELECT * FROM test_dt ORDER BY time;
 SELECT * FROM "testSchema0".hypertable_detailed_size('test_ts');
  table_bytes | index_bytes | toast_bytes | total_bytes | node_name 
 -------------+-------------+-------------+-------------+-----------
-       16384 |       81920 |       16384 |      122880 | 
+       16384 |       81920 |       24576 |      122880 | 
 (1 row)
 
 -- testing hypertable_detailed_size END

test/expected/size_utils.out

@@ -45,7 +45,7 @@ INSERT 0 1
 SELECT * FROM hypertable_detailed_size('"public"."two_Partitions"');
  table_bytes | index_bytes | toast_bytes | total_bytes | node_name 
 -------------+-------------+-------------+-------------+-----------
-       32768 |      475136 |       32768 |      548864 | 
+       32768 |      475136 |       40960 |      548864 | 
 (1 row)
 
 SELECT * FROM hypertable_index_size('"public"."two_Partitions_device_id_timeCustom_idx"');
@@ -153,6 +153,7 @@ SELECT * FROM chunks_detailed_size('toast_test');
  _timescaledb_internal | _hyper_4_9_chunk |        8192 |       16384 |       24576 |       49152 | 
 (1 row)
 
+--
 -- Tests for approximate_row_count()
 --
 -- Regular table
@@ -495,6 +496,12 @@ SELECT * FROM hypertable_index_size(0);
                       
 (1 row)
 
+SELECT * FROM _timescaledb_internal.relation_size(0);
+ total_size | heap_size | index_size | toast_size 
+------------+-----------+------------+------------
+            |           |            |           
+(1 row)
+
 SELECT * FROM hypertable_size(1);
  hypertable_size 
 -----------------
@@ -527,6 +534,12 @@ SELECT * FROM hypertable_index_size(1);
                       
 (1 row)
 
+SELECT * FROM _timescaledb_internal.relation_size(1);
+ total_size | heap_size | index_size | toast_size 
+------------+-----------+------------+------------
+          0 |         0 |          0 |          0
+(1 row)
+
 -- Test size functions with NULL input
 SELECT * FROM hypertable_size(NULL);
  hypertable_size 
@@ -560,6 +573,12 @@ SELECT * FROM hypertable_index_size(NULL);
                       
 (1 row)
 
+SELECT * FROM _timescaledb_internal.relation_size(NULL);
+ total_size | heap_size | index_size | toast_size 
+------------+-----------+------------+------------
+            |           |            |           
+(1 row)
+
 -- Test size functions on regular table
 CREATE TABLE hypersize(time timestamptz, device int);
 CREATE INDEX hypersize_time_idx ON hypersize (time);
@@ -572,6 +591,12 @@ SELECT pg_relation_size('hypersize'), pg_table_size('hypersize'), pg_indexes_siz
                 0 |             0 |            8192 |                   8192 |             8192
 (1 row)
 
+SELECT * FROM _timescaledb_internal.relation_size('hypersize');
+ total_size | heap_size | index_size | toast_size 
+------------+-----------+------------+------------
+       8192 |         0 |       8192 |          0
+(1 row)
+
 SELECT * FROM hypertable_size('hypersize');
  hypertable_size 
 -----------------
@@ -620,6 +645,12 @@ SELECT pg_relation_size('hypersize'), pg_table_size('hypersize'), pg_indexes_siz
                 0 |             0 |            8192 |                   8192 |             8192
 (1 row)
 
+SELECT * FROM _timescaledb_internal.relation_size('hypersize');
+ total_size | heap_size | index_size | toast_size 
+------------+-----------+------------+------------
+       8192 |         0 |       8192 |          0
+(1 row)
+
 SELECT * FROM hypertable_size('hypersize');
  hypertable_size 
 -----------------
@@ -669,6 +700,12 @@ ORDER BY ch;
              8192 |          8192 |           16384 |                  24576
 (1 row)
 
+SELECT * FROM show_chunks('hypersize') ch JOIN LATERAL _timescaledb_internal.relation_size(ch) ON true;
+                   ch                    | total_size | heap_size | index_size | toast_size 
+-----------------------------------------+------------+-----------+------------+------------
+ _timescaledb_internal._hyper_6_11_chunk |      24576 |      8192 |      16384 |          0
+(1 row)
+
 SELECT * FROM hypertable_size('hypersize');
  hypertable_size 
 -----------------

test/sql/size_utils.sql

@@ -21,7 +21,6 @@ INSERT INTO timestamp_partitioned VALUES('2004-10-19 10:23:54', '10');
 INSERT INTO timestamp_partitioned VALUES('2004-12-19 10:23:54', '30');
 SELECT * FROM chunks_detailed_size('timestamp_partitioned') order by chunk_name;
 
-
 CREATE TABLE timestamp_partitioned_2(time TIMESTAMP, value CHAR(9));
 SELECT * FROM create_hypertable('timestamp_partitioned_2', 'time', 'value', 2);
 
@@ -40,6 +39,7 @@ this must be over 2k. this must be over 2k. this must be over 2k. this must be o
 $$);
 SELECT * FROM chunks_detailed_size('toast_test');
 
+--
 -- Tests for approximate_row_count()
 --
 
@@ -213,6 +213,7 @@ SELECT * FROM chunks_detailed_size(0) ORDER BY node_name;
 SELECT * FROM hypertable_compression_stats(0) ORDER BY node_name;
 SELECT * FROM chunk_compression_stats(0) ORDER BY node_name;
 SELECT * FROM hypertable_index_size(0);
+SELECT * FROM _timescaledb_internal.relation_size(0);
 
 SELECT * FROM hypertable_size(1);
 SELECT * FROM hypertable_detailed_size(1) ORDER BY node_name;
@@ -220,6 +221,7 @@ SELECT * FROM chunks_detailed_size(1) ORDER BY node_name;
 SELECT * FROM hypertable_compression_stats(1) ORDER BY node_name;
 SELECT * FROM chunk_compression_stats(1) ORDER BY node_name;
 SELECT * FROM hypertable_index_size(1);
+SELECT * FROM _timescaledb_internal.relation_size(1);
 
 -- Test size functions with NULL input
 SELECT * FROM hypertable_size(NULL);
@@ -228,6 +230,7 @@ SELECT * FROM chunks_detailed_size(NULL) ORDER BY node_name;
 SELECT * FROM hypertable_compression_stats(NULL) ORDER BY node_name;
 SELECT * FROM chunk_compression_stats(NULL) ORDER BY node_name;
 SELECT * FROM hypertable_index_size(NULL);
+SELECT * FROM _timescaledb_internal.relation_size(NULL);
 
 -- Test size functions on regular table
 CREATE TABLE hypersize(time timestamptz, device int);
@@ -236,6 +239,7 @@ CREATE INDEX hypersize_time_idx ON hypersize (time);
 \set VERBOSITY default
 \set SHOW_CONTEXT never
 SELECT pg_relation_size('hypersize'), pg_table_size('hypersize'), pg_indexes_size('hypersize'), pg_total_relation_size('hypersize'), pg_relation_size('hypersize_time_idx');
+SELECT * FROM _timescaledb_internal.relation_size('hypersize');
 SELECT * FROM hypertable_size('hypersize');
 SELECT * FROM hypertable_detailed_size('hypersize') ORDER BY node_name;
 SELECT * FROM chunks_detailed_size('hypersize') ORDER BY node_name;
@@ -248,6 +252,7 @@ SELECT * FROM hypertable_index_size('hypersize_time_idx');
 -- Test size functions on empty hypertable
 SELECT * FROM create_hypertable('hypersize', 'time');
 SELECT pg_relation_size('hypersize'), pg_table_size('hypersize'), pg_indexes_size('hypersize'), pg_total_relation_size('hypersize'), pg_relation_size('hypersize_time_idx');
+SELECT * FROM _timescaledb_internal.relation_size('hypersize');
 SELECT * FROM hypertable_size('hypersize');
 SELECT * FROM hypertable_detailed_size('hypersize') ORDER BY node_name;
 SELECT * FROM chunks_detailed_size('hypersize') ORDER BY node_name;
@@ -261,6 +266,7 @@ SELECT pg_relation_size('hypersize'), pg_table_size('hypersize'), pg_indexes_siz
 SELECT pg_relation_size(ch), pg_table_size(ch), pg_indexes_size(ch), pg_total_relation_size(ch)
 FROM show_chunks('hypersize') ch
 ORDER BY ch;
+SELECT * FROM show_chunks('hypersize') ch JOIN LATERAL _timescaledb_internal.relation_size(ch) ON true;
 SELECT * FROM hypertable_size('hypersize');
 SELECT * FROM hypertable_detailed_size('hypersize') ORDER BY node_name;
 SELECT * FROM chunks_detailed_size('hypersize') ORDER BY node_name;

tsl/src/compression/compress_utils.c

@@ -246,7 +246,7 @@ compress_chunk_impl(Oid hypertable_relid, Oid chunk_relid)
 		FormData_hypertable_compression *fd = (FormData_hypertable_compression *) lfirst(lc);
 		colinfo_array[i++] = fd;
 	}
-	before_size = ts_relation_size(cxt.srcht_chunk->table_id);
+	before_size = ts_relation_size_impl(cxt.srcht_chunk->table_id);
 	cstat = compress_chunk(cxt.srcht_chunk->table_id,
 						   compress_ht_chunk->table_id,
 						   colinfo_array,
@@ -268,7 +268,7 @@ compress_chunk_impl(Oid hypertable_relid, Oid chunk_relid)
 	 * directly on the hypertable or chunks.
 	 */
 	ts_chunk_drop_fks(cxt.srcht_chunk);
-	after_size = ts_relation_size(compress_ht_chunk->table_id);
+	after_size = ts_relation_size_impl(compress_ht_chunk->table_id);
 	compression_chunk_size_catalog_insert(cxt.srcht_chunk->fd.id,
 										  &before_size,
 										  compress_ht_chunk->fd.id,

tsl/test/expected/compression.out

@@ -450,7 +450,7 @@ from hypertable_detailed_size('conditions');
 -[ RECORD 1 ]--+-------
 pg_size_pretty | 16 kB
 pg_size_pretty | 56 kB
-pg_size_pretty | 32 kB
+pg_size_pretty | 40 kB
 pg_size_pretty | 112 kB
 
 select * from timescaledb_information.hypertables

tsl/test/expected/dist_util.out

@@ -256,6 +256,17 @@ FROM show_chunks('disttable') ch;
 ---------------+------------------+-----------------+------------------------
 (0 rows)
 
+SELECT * FROM _timescaledb_internal.relation_size('disttable');
+ total_size | heap_size | index_size | toast_size 
+------------+-----------+------------+------------
+          0 |         0 |          0 |          0
+(1 row)
+
+SELECT * FROM show_chunks('disttable') ch JOIN LATERAL _timescaledb_internal.relation_size(ch) ON TRUE;
+ ch | total_size | heap_size | index_size | toast_size 
+----+------------+-----------+------------+------------
+(0 rows)
+
 SELECT pg_table_size('nondisttable'), pg_relation_size('nondisttable'), pg_indexes_size('nondisttable'), pg_total_relation_size('nondisttable');
  pg_table_size | pg_relation_size | pg_indexes_size | pg_total_relation_size 
 ---------------+------------------+-----------------+------------------------
@@ -268,6 +279,17 @@ FROM show_chunks('nondisttable') ch;
 ---------------+------------------+-----------------+------------------------
 (0 rows)
 
+SELECT * FROM _timescaledb_internal.relation_size('nondisttable');
+ total_size | heap_size | index_size | toast_size 
+------------+-----------+------------+------------
+          0 |         0 |          0 |          0
+(1 row)
+
+SELECT * FROM show_chunks('nondisttable') ch JOIN LATERAL _timescaledb_internal.relation_size(ch) ON TRUE;
+ ch | total_size | heap_size | index_size | toast_size 
+----+------------+-----------+------------+------------
+(0 rows)
+
 SELECT * FROM hypertable_size('disttable');
  hypertable_size 
 -----------------
@@ -334,12 +356,24 @@ SELECT pg_table_size('disttable'), pg_relation_size('disttable'), pg_indexes_siz
              0 |                0 |            8192 |                   8192
 (1 row)
 
+SELECT * FROM _timescaledb_internal.relation_size('disttable');
+ total_size | heap_size | index_size | toast_size 
+------------+-----------+------------+------------
+       8192 |         0 |       8192 |          0
+(1 row)
+
 SELECT pg_table_size('nondisttable'), pg_relation_size('nondisttable'), pg_indexes_size('nondisttable'), pg_total_relation_size('nondisttable');
  pg_table_size | pg_relation_size | pg_indexes_size | pg_total_relation_size 
 ---------------+------------------+-----------------+------------------------
              0 |                0 |            8192 |                   8192
 (1 row)
 
+SELECT * FROM _timescaledb_internal.relation_size('nondisttable');
+ total_size | heap_size | index_size | toast_size 
+------------+-----------+------------+------------
+       8192 |         0 |       8192 |          0
+(1 row)
+
 -- Note that the empty disttable is three times the size of the
 -- nondisttable since it has primary key indexes on two data nodes in
 -- addition to the access node.
@@ -427,6 +461,18 @@ FROM show_chunks('disttable') ch;
              0 |                0 |               0 |                      0
 (1 row)
 
+SELECT * FROM _timescaledb_internal.relation_size('disttable');
+ total_size | heap_size | index_size | toast_size 
+------------+-----------+------------+------------
+       8192 |         0 |       8192 |          0
+(1 row)
+
+SELECT * FROM show_chunks('disttable') ch JOIN LATERAL _timescaledb_internal.relation_size(ch) ON TRUE;
+                     ch                      | total_size | heap_size | index_size | toast_size 
+---------------------------------------------+------------+-----------+------------+------------
+ _timescaledb_internal._dist_hyper_2_2_chunk |          0 |         0 |          0 |          0
+(1 row)
+
 SELECT pg_table_size('nondisttable'), pg_relation_size('nondisttable'), pg_indexes_size('nondisttable'), pg_total_relation_size('nondisttable');
  pg_table_size | pg_relation_size | pg_indexes_size | pg_total_relation_size 
 ---------------+------------------+-----------------+------------------------
@@ -440,6 +486,18 @@ FROM show_chunks('nondisttable') ch;
           8192 |             8192 |           16384 |                  24576
 (1 row)
 
+SELECT * FROM _timescaledb_internal.relation_size('nondisttable');
+ total_size | heap_size | index_size | toast_size 
+------------+-----------+------------+------------
+       8192 |         0 |       8192 |          0
+(1 row)
+
+SELECT * FROM show_chunks('nondisttable') ch JOIN LATERAL _timescaledb_internal.relation_size(ch) ON TRUE;
+                   ch                   | total_size | heap_size | index_size | toast_size 
+----------------------------------------+------------+-----------+------------+------------
+ _timescaledb_internal._hyper_1_1_chunk |      24576 |      8192 |      16384 |          0
+(1 row)
+
 SELECT * FROM hypertable_size('disttable');
  hypertable_size 
 -----------------
@@ -484,6 +542,18 @@ FROM show_chunks('disttable') ch;
              0 |                0 |               0
 (1 row)
 
+SELECT * FROM _timescaledb_internal.relation_size('disttable');
+ total_size | heap_size | index_size | toast_size 
+------------+-----------+------------+------------
+       8192 |         0 |       8192 |          0
+(1 row)
+
+SELECT * FROM show_chunks('disttable') ch JOIN LATERAL _timescaledb_internal.relation_size(ch) ON TRUE;
+                     ch                      | total_size | heap_size | index_size | toast_size 
+---------------------------------------------+------------+-----------+------------+------------
+ _timescaledb_internal._dist_hyper_2_2_chunk |          0 |         0 |          0 |          0
+(1 row)
+
 SELECT pg_table_size('nondisttable'), pg_relation_size('nondisttable'), pg_indexes_size('nondisttable'), pg_total_relation_size('nondisttable');
  pg_table_size | pg_relation_size | pg_indexes_size | pg_total_relation_size 
 ---------------+------------------+-----------------+------------------------
@@ -497,6 +567,18 @@ FROM show_chunks('nondisttable') ch;
              0 |                0 |            8192 |                   8192
 (1 row)
 
+SELECT * FROM _timescaledb_internal.relation_size('nondisttable');
+ total_size | heap_size | index_size | toast_size 
+------------+-----------+------------+------------
+       8192 |         0 |       8192 |          0
+(1 row)
+
+SELECT * FROM show_chunks('nondisttable') ch JOIN LATERAL _timescaledb_internal.relation_size(ch) ON TRUE;
+                   ch                   | total_size | heap_size | index_size | toast_size 
+----------------------------------------+------------+-----------+------------+------------
+ _timescaledb_internal._hyper_1_1_chunk |       8192 |         0 |       8192 |          0
+(1 row)
+
 SELECT * FROM hypertable_size('disttable');
  hypertable_size 
 -----------------

tsl/test/sql/dist_util.sql

@@ -128,9 +128,13 @@ ORDER BY hypertable_schema, hypertable_name;
 SELECT pg_table_size('disttable'), pg_relation_size('disttable'), pg_indexes_size('disttable'), pg_total_relation_size('disttable');
 SELECT pg_table_size(ch), pg_relation_size(ch), pg_indexes_size(ch), pg_total_relation_size(ch)
 FROM show_chunks('disttable') ch;
+SELECT * FROM _timescaledb_internal.relation_size('disttable');
+SELECT * FROM show_chunks('disttable') ch JOIN LATERAL _timescaledb_internal.relation_size(ch) ON TRUE;
 SELECT pg_table_size('nondisttable'), pg_relation_size('nondisttable'), pg_indexes_size('nondisttable'), pg_total_relation_size('nondisttable');
 SELECT pg_table_size(ch), pg_relation_size(ch), pg_indexes_size(ch), pg_total_relation_size(ch)
 FROM show_chunks('nondisttable') ch;
+SELECT * FROM _timescaledb_internal.relation_size('nondisttable');
+SELECT * FROM show_chunks('nondisttable') ch JOIN LATERAL _timescaledb_internal.relation_size(ch) ON TRUE;
 
 SELECT * FROM hypertable_size('disttable');
 SELECT * FROM hypertable_size('nondisttable');
@@ -149,7 +153,9 @@ ALTER TABLE nondisttable ADD CONSTRAINT nondisttable_pkey PRIMARY KEY (time);
 ALTER TABLE disttable ADD CONSTRAINT disttable_pkey PRIMARY KEY (time);
 
 SELECT pg_table_size('disttable'), pg_relation_size('disttable'), pg_indexes_size('disttable'), pg_total_relation_size('disttable');
+SELECT * FROM _timescaledb_internal.relation_size('disttable');
 SELECT pg_table_size('nondisttable'), pg_relation_size('nondisttable'), pg_indexes_size('nondisttable'), pg_total_relation_size('nondisttable');
+SELECT * FROM _timescaledb_internal.relation_size('nondisttable');
 
 -- Note that the empty disttable is three times the size of the
 -- nondisttable since it has primary key indexes on two data nodes in
@@ -175,9 +181,13 @@ INSERT INTO disttable SELECT * FROM nondisttable;
 SELECT pg_table_size('disttable'), pg_relation_size('disttable'), pg_indexes_size('disttable'), pg_total_relation_size('disttable');
 SELECT pg_table_size(ch), pg_relation_size(ch), pg_indexes_size(ch), pg_total_relation_size(ch)
 FROM show_chunks('disttable') ch;
+SELECT * FROM _timescaledb_internal.relation_size('disttable');
+SELECT * FROM show_chunks('disttable') ch JOIN LATERAL _timescaledb_internal.relation_size(ch) ON TRUE;
 SELECT pg_table_size('nondisttable'), pg_relation_size('nondisttable'), pg_indexes_size('nondisttable'), pg_total_relation_size('nondisttable');
 SELECT pg_table_size(ch), pg_relation_size(ch), pg_indexes_size(ch), pg_total_relation_size(ch)
 FROM show_chunks('nondisttable') ch;
+SELECT * FROM _timescaledb_internal.relation_size('nondisttable');
+SELECT * FROM show_chunks('nondisttable') ch JOIN LATERAL _timescaledb_internal.relation_size(ch) ON TRUE;
 
 SELECT * FROM hypertable_size('disttable');
 SELECT * FROM hypertable_detailed_size('disttable') ORDER BY node_name;
@@ -193,9 +203,13 @@ VACUUM FULL ANALYZE disttable;
 SELECT pg_table_size('disttable'), pg_relation_size('disttable'), pg_indexes_size('disttable'), pg_total_relation_size('disttable');
 SELECT pg_table_size(ch), pg_relation_size(ch), pg_indexes_size(ch)
 FROM show_chunks('disttable') ch;
+SELECT * FROM _timescaledb_internal.relation_size('disttable');
+SELECT * FROM show_chunks('disttable') ch JOIN LATERAL _timescaledb_internal.relation_size(ch) ON TRUE;
 SELECT pg_table_size('nondisttable'), pg_relation_size('nondisttable'), pg_indexes_size('nondisttable'), pg_total_relation_size('nondisttable');
 SELECT pg_table_size(ch), pg_relation_size(ch), pg_indexes_size(ch), pg_total_relation_size(ch)
 FROM show_chunks('nondisttable') ch;
+SELECT * FROM _timescaledb_internal.relation_size('nondisttable');
+SELECT * FROM show_chunks('nondisttable') ch JOIN LATERAL _timescaledb_internal.relation_size(ch) ON TRUE;
 
 SELECT * FROM hypertable_size('disttable');
 SELECT * FROM hypertable_detailed_size('disttable') ORDER BY node_name;