Use regclass for storing relation reference in chunk catalog table

The chunk catalog no longer stores the schema and table name; the
chunk relation is referenced by relid instead.

Author: svenklemm

.unreleased/pr_10231

@@ -0,0 +1 @@
+Implements: #10231 Use regclass for storing relation reference in chunk table

scripts/dump_meta_data.sql

@@ -46,7 +46,7 @@ SELECT id, schema_name, table_name, associated_schema_name, associated_table_pre
 SELECT ch.id AS chunk_id, ci.indexrelid::regclass::text AS index_name, h.id AS hypertable_id
 FROM _timescaledb_catalog.hypertable h
 JOIN _timescaledb_catalog.chunk ch ON ch.hypertable_id = h.id
-JOIN pg_index ci ON ci.indrelid = format('%I.%I', ch.schema_name, ch.table_name)::regclass
+JOIN pg_index ci ON ci.indrelid = ch.relid
 ORDER BY h.id, ch.id, ci.indrelid::regclass::text;
 
 \echo 'Size of hypertables'
@@ -59,8 +59,8 @@ SELECT hypertable,
        SELECT *, total_bytes-index_bytes-COALESCE(toast_bytes,0) AS table_bytes FROM (
               SELECT
               pgc.oid::regclass::text as hypertable,
-              sum(pg_total_relation_size('"' || c.schema_name || '"."' || c.table_name || '"'))::bigint as total_bytes,
-              sum(pg_indexes_size('"' || c.schema_name || '"."' || c.table_name || '"'))::bigint AS index_bytes,
+              sum(pg_total_relation_size(c.relid))::bigint as total_bytes,
+              sum(pg_indexes_size(c.relid))::bigint AS index_bytes,
               sum(pg_total_relation_size(reltoastrelid))::bigint AS toast_bytes
               FROM
               _timescaledb_catalog.hypertable h,
@@ -92,9 +92,9 @@ SELECT *,
       total_bytes-index_bytes-COALESCE(toast_bytes,0) AS table_bytes
       FROM (
        SELECT c.id as chunk_id,
-       '"' || c.schema_name || '"."' || c.table_name || '"' as chunk_table,
-       pg_total_relation_size('"' || c.schema_name || '"."' || c.table_name || '"') AS total_bytes,
-       pg_indexes_size('"' || c.schema_name || '"."' || c.table_name || '"') AS index_bytes,
+       c.relid::text as chunk_table,
+       pg_total_relation_size(c.relid) AS total_bytes,
+       pg_indexes_size(c.relid) AS index_bytes,
        pg_total_relation_size(reltoastrelid) AS toast_bytes,
        array_agg(d.column_name ORDER BY d.interval_length, d.column_name ASC) as partitioning_columns,
        array_agg(d.column_type ORDER BY d.interval_length, d.column_name ASC) as partitioning_column_types,

sql/chunk_constraint.sql

@@ -14,13 +14,19 @@ $BODY$
 DECLARE
     chunk_row _timescaledb_catalog.chunk;
     hypertable_row _timescaledb_catalog.hypertable;
+    chunk_schema NAME;
+    chunk_table NAME;
     constraint_oid OID;
     constraint_type CHAR;
     def TEXT;
     indx_tablespace NAME;
 BEGIN
     SELECT * INTO STRICT chunk_row FROM _timescaledb_catalog.chunk c WHERE c.id = chunk_id;
     SELECT * INTO STRICT hypertable_row FROM _timescaledb_catalog.hypertable h WHERE h.id = chunk_row.hypertable_id;
+    -- schema_name and table_name are derived from the chunk relation
+    SELECT n.nspname, c.relname INTO STRICT chunk_schema, chunk_table
+    FROM pg_catalog.pg_class c JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
+    WHERE c.oid = chunk_row.relid;
 
     SELECT oid, contype INTO STRICT constraint_oid, constraint_type FROM pg_constraint
     WHERE conname = hypertable_constraint_name AND
@@ -50,13 +56,13 @@ BEGIN
         SET LOCAL search_path TO @extschema@, pg_temp;
         EXECUTE pg_catalog.format(
             $$ ALTER TABLE %I.%I ADD CONSTRAINT %I %s $$,
-            chunk_row.schema_name, chunk_row.table_name, constraint_name, def
+            chunk_schema, chunk_table, constraint_name, def
         );
 
         IF indx_tablespace IS NOT NULL THEN
             EXECUTE pg_catalog.format(
                 $$ ALTER INDEX %I.%I SET TABLESPACE %I $$,
-                chunk_row.schema_name, constraint_name, indx_tablespace
+                chunk_schema, constraint_name, indx_tablespace
             );
         END IF;
     END IF;

sql/maintenance_utils.sql

@@ -128,9 +128,8 @@ BEGIN
     SELECT id FROM _timescaledb_catalog.chunk
     WHERE hypertable_id = _hypertable_id
     AND NOT EXISTS (
-        SELECT FROM information_schema.tables
-        WHERE tables.table_schema = chunk.schema_name
-        AND tables.table_name = chunk.table_name
+        SELECT FROM pg_catalog.pg_class
+        WHERE pg_class.oid = chunk.relid
     )
   LOOP
     _removed := _removed + 1;
@@ -147,8 +146,7 @@ BEGIN
     OR compression_chunk_size.compressed_chunk_id = _chunk_id;
 
     DELETE FROM _timescaledb_catalog.chunk
-    WHERE chunk.id = _chunk_id
-    OR chunk.compressed_chunk_id = _chunk_id;
+    WHERE chunk.id = _chunk_id;
   END LOOP;
 
   RETURN _removed;

sql/osm_api.sql

@@ -74,24 +74,26 @@ CREATE OR REPLACE FUNCTION _timescaledb_functions.get_chunk_info(IN chunk REGCLA
   SELECT
 		ch.id AS chunk_id,
 		ch.hypertable_id, ht.schema_name AS ht_schema_name, ht.table_name AS ht_table_name,
-    ch.schema_name AS chunk_schema, ch.table_name AS chunk_name,
+    ns.nspname AS chunk_schema, c.relname AS chunk_name,
     ch.osm_chunk AS is_osm_chunk,
     (ch.status & 4)::bool AS is_frozen
 	FROM _timescaledb_catalog.chunk ch
-  JOIN pg_class c ON c.oid=$1 AND ch.table_name=c.relname
-  JOIN pg_namespace ns ON ns.oid = c.relnamespace AND ns.nspname = ch.schema_name
+  JOIN pg_class c ON c.oid = ch.relid AND c.oid = $1
+  JOIN pg_namespace ns ON ns.oid = c.relnamespace
   JOIN _timescaledb_catalog.hypertable ht ON ht.id=ch.hypertable_id;
 $$ LANGUAGE SQL STABLE SET search_path = pg_catalog, pg_temp;
 
 CREATE OR REPLACE FUNCTION _timescaledb_functions.get_chunk_info_by_id(IN chunk_id INTEGER, OUT chunk_id INTEGER, OUT hypertable_id INTEGER, OUT ht_schema_name NAME, OUT ht_table_name NAME, OUT chunk_schema NAME, OUT chunk_name NAME, OUT is_osm_chunk BOOLEAN, OUT is_frozen BOOLEAN) AS $$
   SELECT
 		ch.id AS chunk_id,
 		ch.hypertable_id, ht.schema_name AS ht_schema_name, ht.table_name AS ht_table_name,
-    ch.schema_name AS chunk_schema, ch.table_name AS chunk_name,
+    ns.nspname AS chunk_schema, c.relname AS chunk_name,
     ch.osm_chunk AS is_osm_chunk,
     (ch.status & 4)::bool AS is_frozen
 	FROM _timescaledb_catalog.chunk ch
   JOIN _timescaledb_catalog.hypertable ht ON ht.id=ch.hypertable_id
+  JOIN pg_class c ON c.oid = ch.relid
+  JOIN pg_namespace ns ON ns.oid = c.relnamespace
   WHERE ch.id = $1;
 $$ LANGUAGE SQL STABLE SET search_path = pg_catalog, pg_temp;
 
@@ -100,8 +102,7 @@ AS $$
   SELECT range_start, range_end
   FROM _timescaledb_catalog.dimension_slice d
   JOIN _timescaledb_catalog.chunk ch ON ch.id = d.chunk_id
-  JOIN pg_class c ON c.oid=$1 AND ch.table_name=c.relname
-  JOIN pg_namespace ns ON ns.oid = c.relnamespace AND ns.nspname = ch.schema_name
+  WHERE ch.relid = $1
   ORDER BY dimension_id LIMIT 1;
 $$ LANGUAGE SQL STABLE SET search_path = pg_catalog, pg_temp;
 

sql/policy_internal.sql

@@ -57,7 +57,7 @@ BEGIN
   inactive_for := jsonb_object_field_text(config, 'inactive_for')::INTERVAL;
 
   FOR chunk_rec IN
-    SELECT ch.schema_name, ch.table_name
+    SELECT ch.relid
     FROM _timescaledb_catalog.chunk ch
     WHERE ch.hypertable_id = htid
       AND NOT ch.osm_chunk
@@ -70,20 +70,19 @@ BEGIN
       -- so we don't keep recompacting chunks still receiving out-of-order data
       AND (inactive_for IS NULL OR NOT EXISTS (
         SELECT 1 FROM _timescaledb_functions.chunk_statistics(
-          uncompressed_relid => format('%I.%I', ch.schema_name, ch.table_name)::regclass) s
+          uncompressed_relid => ch.relid) s
         WHERE s.last_update >= now() - inactive_for))
   LOOP
     BEGIN
-      PERFORM _timescaledb_functions.compact_chunk(
-        format('%I.%I', chunk_rec.schema_name, chunk_rec.table_name)::regclass);
+      PERFORM _timescaledb_functions.compact_chunk(chunk_rec.relid);
       numchunks := numchunks + 1;
     EXCEPTION WHEN OTHERS THEN
       GET STACKED DIAGNOSTICS
           _message = MESSAGE_TEXT,
           _detail = PG_EXCEPTION_DETAIL,
           _sqlstate = RETURNED_SQLSTATE;
-      RAISE WARNING 'compaction policy failed to compact chunk "%.%"',
-          chunk_rec.schema_name, chunk_rec.table_name
+      RAISE WARNING 'compaction policy failed to compact chunk "%"',
+          chunk_rec.relid
           USING DETAIL = format('Message: (%s), Detail: (%s).', _message, _detail),
                 ERRCODE = _sqlstate;
       chunks_failure := chunks_failure + 1;
@@ -96,7 +95,7 @@ BEGIN
     -- search_path to caller, so we do SET LOCAL again after COMMIT
     SET LOCAL search_path TO pg_catalog, pg_temp;
     IF verbose_log THEN
-      RAISE LOG 'job % completed compacting chunk %.%', job_id, chunk_rec.schema_name, chunk_rec.table_name;
+      RAISE LOG 'job % completed compacting chunk %', job_id, chunk_rec.relid;
     END IF;
     -- max_chunks bounds the chunks processed per run, including ones that failed
     IF max_chunks > 0 AND processed >= max_chunks THEN
@@ -187,12 +186,12 @@ BEGIN
 
   FOR chunk_rec IN
     SELECT
-      show.oid, ch.schema_name, ch.table_name, ch.status
+      show.oid, pgns.nspname AS schema_name, pgc.relname AS table_name, ch.status
     FROM
       @extschema@.show_chunks(htoid, older_than => lag, created_before => creation_lag) AS show(oid)
       INNER JOIN pg_class pgc ON pgc.oid = show.oid
       INNER JOIN pg_namespace pgns ON pgc.relnamespace = pgns.oid
-      INNER JOIN _timescaledb_catalog.chunk ch ON ch.table_name = pgc.relname AND ch.schema_name = pgns.nspname AND ch.hypertable_id = htid
+      INNER JOIN _timescaledb_catalog.chunk ch ON ch.relid = show.oid AND ch.hypertable_id = htid
     WHERE NOT ch.osm_chunk
     -- Checking for chunks which are not fully compressed and not frozen
     AND ch.status != status_fully_compressed
@@ -227,7 +226,7 @@ BEGIN
       FOR idx_rec IN
         SELECT idx.schemaname, idx.indexname
         FROM pg_indexes idx
-        JOIN _timescaledb_catalog.chunk ch ON ch.schema_name = idx.schemaname AND ch.table_name = idx.tablename
+        JOIN _timescaledb_catalog.chunk ch ON ch.relid = chunk_rec.oid
         WHERE idx.schemaname = chunk_rec.schema_name
           AND idx.tablename = chunk_rec.table_name
           AND ch.status = status_fully_compressed

sql/pre_install/tables.sql

@@ -120,16 +120,14 @@ CREATE SEQUENCE _timescaledb_catalog.chunk_id_seq MINVALUE 1;
 
 CREATE TABLE _timescaledb_catalog.chunk (
   id integer NOT NULL DEFAULT nextval('_timescaledb_catalog.chunk_id_seq'),
+  relid regclass NOT NULL,
   hypertable_id int NOT NULL,
-  schema_name name NOT NULL,
-  table_name name NOT NULL,
-  compressed_chunk_id integer ,
   status integer NOT NULL DEFAULT 0,
   osm_chunk boolean NOT NULL DEFAULT FALSE,
   creation_time timestamptz NOT NULL,
   -- table constraints
   CONSTRAINT chunk_pkey PRIMARY KEY (id),
-  CONSTRAINT chunk_schema_name_table_name_key UNIQUE (schema_name, table_name),
+  CONSTRAINT chunk_relid_key UNIQUE (relid),
   CONSTRAINT chunk_hypertable_id_fkey FOREIGN KEY (hypertable_id) REFERENCES _timescaledb_catalog.hypertable (id)
 ) WITH (user_catalog_table = true);
 ALTER SEQUENCE _timescaledb_catalog.chunk_id_seq OWNED BY _timescaledb_catalog.chunk.id;

sql/size_utils.sql

@@ -22,8 +22,8 @@ SELECT
     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,
+    n.nspname AS chunk_schema,
+    cl.relname AS 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,
@@ -35,9 +35,8 @@ SELECT
 FROM
     _timescaledb_catalog.hypertable h
     JOIN _timescaledb_catalog.chunk c ON h.id = c.hypertable_id
-    JOIN pg_class cl ON cl.relname = c.table_name AND cl.relkind = 'r'
+    JOIN pg_class cl ON cl.oid = c.relid AND cl.relkind = 'r'
     JOIN pg_namespace n ON n.oid = cl.relnamespace
-    AND n.nspname = c.schema_name
     JOIN LATERAL _timescaledb_functions.relation_size(cl.oid) AS relsize ON TRUE
     LEFT JOIN _timescaledb_catalog.compression_settings cs ON cs.relid = cl.oid
     LEFT JOIN LATERAL _timescaledb_functions.relation_size(cs.compress_relid) AS relcompsize ON TRUE;
@@ -340,7 +339,7 @@ BEGIN
     -- for hypertables return the sum of the row counts of all chunks
     SELECT id FROM _timescaledb_catalog.hypertable INTO v_hypertable_id WHERE table_name = v_name AND schema_name = v_schema;
     IF FOUND THEN
-        RETURN (SELECT coalesce(sum(_timescaledb_functions.get_approx_row_count(format('%I.%I',schema_name,table_name))),0)
+        RETURN (SELECT coalesce(sum(_timescaledb_functions.get_approx_row_count(relid)),0)
           FROM _timescaledb_catalog.chunk
           WHERE hypertable_id = v_hypertable_id);
     END IF;
@@ -392,8 +391,8 @@ CREATE OR REPLACE VIEW _timescaledb_internal.compressed_chunk_stats AS
 SELECT
     srcht.schema_name AS hypertable_schema,
     srcht.table_name AS hypertable_name,
-    srcch.schema_name AS chunk_schema,
-    srcch.table_name AS chunk_name,
+    n.nspname AS chunk_schema,
+    cl.relname AS chunk_name,
     CASE WHEN srcch.status & 1 = 1 THEN
         'Compressed'::text
     ELSE
@@ -411,6 +410,8 @@ FROM
     _timescaledb_catalog.hypertable AS srcht
     JOIN _timescaledb_catalog.chunk AS srcch ON srcht.id = srcch.hypertable_id
         AND srcht.status & 4 = 4
+    JOIN pg_class cl ON cl.oid = srcch.relid
+    JOIN pg_namespace n ON n.oid = cl.relnamespace
     LEFT JOIN _timescaledb_catalog.compression_chunk_size map ON srcch.id = map.chunk_id;
 
 GRANT SELECT ON _timescaledb_internal.compressed_chunk_stats TO PUBLIC;

sql/updates/latest-dev.sql

@@ -68,13 +68,82 @@ SET status = status | 4, -- set compression bit
     compression_state = 0
 WHERE compression_state = 1;
 
---
--- END set compression status flag on hypertables
---
-
 ALTER TABLE _timescaledb_catalog.hypertable DROP CONSTRAINT hypertable_dim_compress_check;
 ALTER TABLE _timescaledb_catalog.hypertable ADD CONSTRAINT hypertable_num_dimensions_check CHECK (num_dimensions > 0);
 ALTER TABLE _timescaledb_catalog.hypertable DROP CONSTRAINT hypertable_compress_check;
 
+--
+-- END set compression status flag on hypertables
+--
+
 DROP FUNCTION IF EXISTS @extschema@.alter_job(job_id INTEGER, schedule_interval INTERVAL, max_runtime INTERVAL, max_retries INTEGER, retry_period INTERVAL, scheduled BOOL, config JSONB, next_start TIMESTAMPTZ, if_exists BOOL, check_config REGPROC, fixed_schedule BOOL, initial_start TIMESTAMPTZ, timezone TEXT, job_name TEXT);
 
+--
+-- BEGIN add chunk.relid and drop chunk.compressed_chunk_id, schema_name, table_name
+--
+
+CREATE TABLE _timescaledb_internal.tmp_chunk AS SELECT * FROM _timescaledb_catalog.chunk;
+CREATE TABLE _timescaledb_internal.tmp_chunk_seq_value AS SELECT last_value, is_called FROM _timescaledb_catalog.chunk_id_seq;
+
+-- drop foreign keys referencing the chunk table
+ALTER TABLE _timescaledb_catalog.dimension_slice DROP CONSTRAINT dimension_slice_chunk_id_fkey;
+ALTER TABLE _timescaledb_catalog.chunk_column_stats DROP CONSTRAINT chunk_column_stats_chunk_id_fkey;
+ALTER TABLE _timescaledb_internal.bgw_policy_chunk_stats DROP CONSTRAINT bgw_policy_chunk_stats_chunk_id_fkey;
+ALTER TABLE _timescaledb_catalog.compression_chunk_size DROP CONSTRAINT compression_chunk_size_chunk_id_fkey;
+
+-- drop dependent views, they are recreated later in the update
+DROP VIEW IF EXISTS _timescaledb_internal.hypertable_chunk_local_size;
+DROP VIEW IF EXISTS _timescaledb_internal.compressed_chunk_stats;
+
+ALTER EXTENSION timescaledb DROP TABLE _timescaledb_catalog.chunk;
+ALTER EXTENSION timescaledb DROP SEQUENCE _timescaledb_catalog.chunk_id_seq;
+
+DROP TABLE _timescaledb_catalog.chunk;
+
+CREATE SEQUENCE _timescaledb_catalog.chunk_id_seq MINVALUE 1;
+
+CREATE TABLE _timescaledb_catalog.chunk (
+  id integer NOT NULL DEFAULT nextval('_timescaledb_catalog.chunk_id_seq'),
+  relid regclass NOT NULL,
+  hypertable_id int NOT NULL,
+  status integer NOT NULL DEFAULT 0,
+  osm_chunk boolean NOT NULL DEFAULT FALSE,
+  creation_time timestamptz NOT NULL,
+  CONSTRAINT chunk_pkey PRIMARY KEY (id),
+  CONSTRAINT chunk_relid_key UNIQUE (relid)
+) WITH (user_catalog_table = true);
+
+INSERT INTO _timescaledb_catalog.chunk
+  (id, relid, hypertable_id, status, osm_chunk, creation_time)
+SELECT
+  id, format('%I.%I', schema_name, table_name)::regclass, hypertable_id, status, osm_chunk, creation_time
+FROM _timescaledb_internal.tmp_chunk;
+
+CREATE INDEX chunk_hypertable_id_idx ON _timescaledb_catalog.chunk (hypertable_id);
+CREATE INDEX chunk_osm_chunk_idx ON _timescaledb_catalog.chunk (osm_chunk, hypertable_id);
+CREATE INDEX chunk_hypertable_id_creation_time_idx ON _timescaledb_catalog.chunk (hypertable_id, creation_time);
+
+ALTER SEQUENCE _timescaledb_catalog.chunk_id_seq OWNED BY _timescaledb_catalog.chunk.id;
+SELECT setval('_timescaledb_catalog.chunk_id_seq', last_value, is_called) FROM _timescaledb_internal.tmp_chunk_seq_value;
+
+ALTER TABLE _timescaledb_catalog.chunk ADD CONSTRAINT chunk_hypertable_id_fkey FOREIGN KEY (hypertable_id) REFERENCES _timescaledb_catalog.hypertable (id);
+
+SELECT pg_catalog.pg_extension_config_dump('_timescaledb_catalog.chunk', '');
+SELECT pg_catalog.pg_extension_config_dump('_timescaledb_catalog.chunk_id_seq', '');
+
+-- restore foreign keys referencing the chunk table
+ALTER TABLE _timescaledb_catalog.dimension_slice ADD CONSTRAINT dimension_slice_chunk_id_fkey FOREIGN KEY (chunk_id) REFERENCES _timescaledb_catalog.chunk (id) ON DELETE CASCADE;
+ALTER TABLE _timescaledb_catalog.chunk_column_stats ADD CONSTRAINT chunk_column_stats_chunk_id_fkey FOREIGN KEY (chunk_id) REFERENCES _timescaledb_catalog.chunk (id);
+ALTER TABLE _timescaledb_internal.bgw_policy_chunk_stats ADD CONSTRAINT bgw_policy_chunk_stats_chunk_id_fkey FOREIGN KEY (chunk_id) REFERENCES _timescaledb_catalog.chunk (id) ON DELETE CASCADE;
+ALTER TABLE _timescaledb_catalog.compression_chunk_size ADD CONSTRAINT compression_chunk_size_chunk_id_fkey FOREIGN KEY (chunk_id) REFERENCES _timescaledb_catalog.chunk (id) ON DELETE CASCADE;
+
+DROP TABLE _timescaledb_internal.tmp_chunk;
+DROP TABLE _timescaledb_internal.tmp_chunk_seq_value;
+
+GRANT SELECT ON _timescaledb_catalog.chunk_id_seq TO PUBLIC;
+GRANT SELECT ON _timescaledb_catalog.chunk TO PUBLIC;
+
+--
+-- END add chunk.relid
+--
+