mirror of
https://github.com/timescale/timescaledb.git
synced 2025-05-15 18:13:18 +08:00
c697700add
This PR introduces a new `distributed` argument to the create_hypertable() function as well as two new GUC's to control its default behaviour: timescaledb.hypertable_distributed_default and timescaledb.hypertable_replication_factor_default. The main idea of this change is to allow automatic creation of the distributed hypertables by default.
312 lines
16 KiB
SQL
312 lines
16 KiB
SQL
DROP VIEW IF EXISTS timescaledb_information.job_stats;
|
|
DROP VIEW IF EXISTS timescaledb_information.jobs;
|
|
DROP FUNCTION IF EXISTS @extschema@.add_retention_policy(REGCLASS, "any", BOOL, INTERVAL);
|
|
CREATE FUNCTION @extschema@.add_retention_policy(relation REGCLASS, drop_after "any", if_not_exists BOOL = false)
|
|
RETURNS INTEGER AS '@MODULE_PATHNAME@', 'ts_policy_retention_add' LANGUAGE C VOLATILE STRICT;
|
|
|
|
DROP FUNCTION IF EXISTS @extschema@.add_compression_policy(REGCLASS, "any", BOOL, INTERVAL);
|
|
CREATE FUNCTION @extschema@.add_compression_policy(hypertable REGCLASS, compress_after "any", if_not_exists BOOL = false)
|
|
RETURNS INTEGER AS '@MODULE_PATHNAME@', 'ts_policy_compression_add' LANGUAGE C VOLATILE STRICT;
|
|
|
|
DROP FUNCTION IF EXISTS @extschema@.detach_data_node;
|
|
CREATE FUNCTION @extschema@.detach_data_node(
|
|
node_name NAME,
|
|
hypertable REGCLASS = NULL,
|
|
if_attached BOOLEAN = FALSE,
|
|
force BOOLEAN = FALSE,
|
|
repartition BOOLEAN = TRUE
|
|
) RETURNS INTEGER
|
|
AS '@MODULE_PATHNAME@', 'ts_data_node_detach' LANGUAGE C VOLATILE;
|
|
|
|
DROP FUNCTION _timescaledb_internal.attach_osm_table_chunk( hypertable REGCLASS, chunk REGCLASS);
|
|
DROP FUNCTION _timescaledb_internal.alter_job_set_hypertable_id( job_id INTEGER, hypertable REGCLASS );
|
|
DROP FUNCTION _timescaledb_internal.unfreeze_chunk( chunk REGCLASS);
|
|
-- Drop dimension partition metadata table
|
|
ALTER EXTENSION timescaledb DROP TABLE _timescaledb_catalog.dimension_partition;
|
|
DROP TABLE IF EXISTS _timescaledb_catalog.dimension_partition;
|
|
|
|
DROP FUNCTION IF EXISTS timescaledb_experimental.add_policies;
|
|
DROP FUNCTION IF EXISTS timescaledb_experimental.remove_policies;
|
|
DROP FUNCTION IF EXISTS timescaledb_experimental.remove_all_policies;
|
|
DROP FUNCTION IF EXISTS timescaledb_experimental.alter_policies;
|
|
DROP FUNCTION IF EXISTS timescaledb_experimental.show_policies;
|
|
DROP FUNCTION IF EXISTS @extschema@.remove_continuous_aggregate_policy(REGCLASS, BOOL, BOOL);
|
|
CREATE FUNCTION @extschema@.remove_continuous_aggregate_policy(continuous_aggregate REGCLASS, if_not_exists BOOL = false)
|
|
RETURNS VOID
|
|
AS '@MODULE_PATHNAME@', 'ts_policy_refresh_cagg_remove'
|
|
LANGUAGE C VOLATILE STRICT;
|
|
|
|
DROP VIEW IF EXISTS timescaledb_experimental.policies;
|
|
|
|
--
|
|
-- Rebuild the catalog table `_timescaledb_catalog.chunk`
|
|
--
|
|
-- We need to recreate the catalog from scratch because when we drop a column
|
|
-- Postgres marks `pg_attribute.attisdropped=TRUE` instead of removing it from
|
|
-- the `pg_catalog.pg_attribute` table.
|
|
--
|
|
-- If we downgrade and upgrade the extension without rebuilding the catalog table it
|
|
-- will mess up `pg_attribute.attnum` and we will end up with issues when trying
|
|
-- to update data in those catalog tables.
|
|
|
|
-- Recreate _timescaledb_catalog.chunk table --
|
|
CREATE TABLE _timescaledb_internal.chunk_tmp
|
|
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 on chunk table
|
|
ALTER TABLE _timescaledb_catalog.chunk_constraint DROP CONSTRAINT
|
|
chunk_constraint_chunk_id_fkey;
|
|
ALTER TABLE _timescaledb_catalog.chunk_index DROP CONSTRAINT
|
|
chunk_index_chunk_id_fkey;
|
|
ALTER TABLE _timescaledb_catalog.chunk_data_node DROP CONSTRAINT
|
|
chunk_data_node_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;
|
|
ALTER TABLE _timescaledb_catalog.compression_chunk_size DROP CONSTRAINT
|
|
compression_chunk_size_compressed_chunk_id_fkey;
|
|
ALTER TABLE _timescaledb_catalog.chunk_copy_operation DROP CONSTRAINT
|
|
chunk_copy_operation_chunk_id_fkey;
|
|
|
|
--drop dependent views
|
|
DROP VIEW IF EXISTS timescaledb_information.hypertables;
|
|
DROP VIEW IF EXISTS timescaledb_information.chunks;
|
|
DROP VIEW IF EXISTS _timescaledb_internal.hypertable_chunk_local_size;
|
|
DROP VIEW IF EXISTS _timescaledb_internal.compressed_chunk_stats;
|
|
DROP VIEW IF EXISTS timescaledb_experimental.chunk_replication_status;
|
|
|
|
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;
|
|
|
|
-- now create table without self referential foreign key
|
|
CREATE TABLE _timescaledb_catalog.chunk (
|
|
id integer NOT NULL DEFAULT nextval('_timescaledb_catalog.chunk_id_seq'),
|
|
hypertable_id int NOT NULL,
|
|
schema_name name NOT NULL,
|
|
table_name name NOT NULL,
|
|
compressed_chunk_id integer ,
|
|
dropped boolean NOT NULL DEFAULT FALSE,
|
|
status integer NOT NULL DEFAULT 0,
|
|
-- table constraints
|
|
CONSTRAINT chunk_pkey PRIMARY KEY (id),
|
|
CONSTRAINT chunk_schema_name_table_name_key UNIQUE (schema_name, table_name)
|
|
);
|
|
|
|
INSERT INTO _timescaledb_catalog.chunk
|
|
( id, hypertable_id, schema_name, table_name,
|
|
compressed_chunk_id, dropped, status)
|
|
SELECT id, hypertable_id, schema_name, table_name,
|
|
compressed_chunk_id, dropped, status
|
|
FROM _timescaledb_internal.chunk_tmp;
|
|
|
|
--add indexes to the chunk table
|
|
CREATE INDEX chunk_hypertable_id_idx ON _timescaledb_catalog.chunk (hypertable_id);
|
|
CREATE INDEX chunk_compressed_chunk_id_idx ON _timescaledb_catalog.chunk (compressed_chunk_id);
|
|
|
|
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;
|
|
|
|
-- add self referential foreign key
|
|
ALTER TABLE _timescaledb_catalog.chunk ADD CONSTRAINT chunk_compressed_chunk_id_fkey FOREIGN KEY ( compressed_chunk_id )
|
|
REFERENCES _timescaledb_catalog.chunk( id );
|
|
|
|
--add foreign key constraint
|
|
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', '');
|
|
|
|
--add the foreign key constraints
|
|
ALTER TABLE _timescaledb_catalog.chunk_constraint ADD CONSTRAINT
|
|
chunk_constraint_chunk_id_fkey FOREIGN KEY (chunk_id) REFERENCES _timescaledb_catalog.chunk(id);
|
|
ALTER TABLE _timescaledb_catalog.chunk_index ADD CONSTRAINT
|
|
chunk_index_chunk_id_fkey FOREIGN KEY (chunk_id)
|
|
REFERENCES _timescaledb_catalog.chunk(id) ON DELETE CASCADE;
|
|
ALTER TABLE _timescaledb_catalog.chunk_data_node ADD CONSTRAINT
|
|
chunk_data_node_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;
|
|
ALTER TABLE _timescaledb_catalog.compression_chunk_size ADD CONSTRAINT
|
|
compression_chunk_size_compressed_chunk_id_fkey FOREIGN KEY (compressed_chunk_id)
|
|
REFERENCES _timescaledb_catalog.chunk(id) ON DELETE CASCADE;
|
|
ALTER TABLE _timescaledb_catalog.chunk_copy_operation ADD CONSTRAINT
|
|
chunk_copy_operation_chunk_id_fkey FOREIGN KEY (chunk_id) REFERENCES _timescaledb_catalog.chunk (id) ON DELETE CASCADE;
|
|
|
|
--cleanup
|
|
DROP TABLE _timescaledb_internal.chunk_tmp;
|
|
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 recreate _timescaledb_catalog.chunk table --
|
|
|
|
ALTER TABLE _timescaledb_internal.bgw_job_stat
|
|
DROP CONSTRAINT bgw_job_stat_job_id_fkey;
|
|
ALTER TABLE _timescaledb_internal.bgw_policy_chunk_stats
|
|
DROP CONSTRAINT bgw_policy_chunk_stats_chunk_id_fkey,
|
|
DROP CONSTRAINT bgw_policy_chunk_stats_job_id_fkey;
|
|
|
|
ALTER TABLE _timescaledb_config.bgw_job
|
|
DROP COLUMN check_schema,
|
|
DROP COLUMN check_name;
|
|
CREATE TABLE _timescaledb_config.bgw_job_tmp (LIKE _timescaledb_config.bgw_job);
|
|
INSERT INTO _timescaledb_config.bgw_job_tmp SELECT * FROM _timescaledb_config.bgw_job;
|
|
CREATE TABLE _timescaledb_internal.tmp_bgw_job_seq_value AS
|
|
SELECT last_value, is_called FROM _timescaledb_config.bgw_job_id_seq;
|
|
|
|
ALTER EXTENSION timescaledb DROP TABLE _timescaledb_config.bgw_job;
|
|
ALTER EXTENSION timescaledb DROP SEQUENCE _timescaledb_config.bgw_job_id_seq;
|
|
|
|
DROP TABLE _timescaledb_config.bgw_job;
|
|
|
|
CREATE SEQUENCE _timescaledb_config.bgw_job_id_seq MINVALUE 1000;
|
|
SELECT pg_catalog.pg_extension_config_dump('_timescaledb_config.bgw_job_id_seq', '');
|
|
SELECT pg_catalog.setval('_timescaledb_config.bgw_job_id_seq', last_value, is_called)
|
|
FROM _timescaledb_internal.tmp_bgw_job_seq_value;
|
|
DROP TABLE _timescaledb_internal.tmp_bgw_job_seq_value;
|
|
|
|
CREATE TABLE _timescaledb_config.bgw_job (
|
|
id integer PRIMARY KEY DEFAULT nextval('_timescaledb_config.bgw_job_id_seq'),
|
|
application_name name NOT NULL,
|
|
schedule_interval interval NOT NULL,
|
|
max_runtime interval NOT NULL,
|
|
max_retries integer NOT NULL,
|
|
retry_period interval NOT NULL,
|
|
proc_schema name NOT NULL,
|
|
proc_name name NOT NULL,
|
|
owner name NOT NULL DEFAULT CURRENT_ROLE,
|
|
scheduled bool NOT NULL DEFAULT TRUE,
|
|
hypertable_id integer REFERENCES _timescaledb_catalog.hypertable (id) ON DELETE CASCADE,
|
|
config jsonb
|
|
);
|
|
|
|
INSERT INTO _timescaledb_config.bgw_job SELECT * FROM _timescaledb_config.bgw_job_tmp ORDER BY id;
|
|
DROP TABLE _timescaledb_config.bgw_job_tmp;
|
|
|
|
ALTER SEQUENCE _timescaledb_config.bgw_job_id_seq OWNED BY _timescaledb_config.bgw_job.id;
|
|
|
|
CREATE INDEX bgw_job_proc_hypertable_id_idx
|
|
ON _timescaledb_config.bgw_job (proc_schema, proc_name, hypertable_id);
|
|
SELECT pg_catalog.pg_extension_config_dump('_timescaledb_config.bgw_job', 'WHERE id >= 1000');
|
|
GRANT SELECT ON _timescaledb_config.bgw_job TO PUBLIC;
|
|
GRANT SELECT ON _timescaledb_config.bgw_job_id_seq TO PUBLIC;
|
|
|
|
ALTER TABLE _timescaledb_internal.bgw_job_stat
|
|
ADD CONSTRAINT bgw_job_stat_job_id_fkey
|
|
FOREIGN KEY(job_id) REFERENCES _timescaledb_config.bgw_job(id)
|
|
ON DELETE CASCADE;
|
|
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,
|
|
ADD CONSTRAINT bgw_policy_chunk_stats_job_id_fkey
|
|
FOREIGN KEY(job_id) REFERENCES _timescaledb_config.bgw_job(id)
|
|
ON DELETE CASCADE;
|
|
|
|
DROP FUNCTION IF EXISTS @extschema@.add_job(REGPROC, INTERVAL, JSONB, TIMESTAMPTZ, BOOL, REGPROC);
|
|
DROP FUNCTION IF EXISTS _timescaledb_internal.policy_retention_check(JSONB);
|
|
DROP FUNCTION IF EXISTS _timescaledb_internal.policy_compression_check(JSONB);
|
|
DROP FUNCTION IF EXISTS _timescaledb_internal.policy_reorder_check(JSONB);
|
|
DROP FUNCTION IF EXISTS _timescaledb_internal.policy_refresh_continuous_aggregate_check(JSONB);
|
|
DROP FUNCTION IF EXISTS @extschema@.alter_job(INTEGER, INTERVAL, INTERVAL, INTEGER, INTERVAL, BOOL, JSONB, TIMESTAMPTZ, BOOL, REGPROC);
|
|
|
|
CREATE FUNCTION @extschema@.add_job(proc REGPROC,
|
|
schedule_interval INTERVAL,
|
|
config JSONB = NULL,
|
|
initial_start TIMESTAMPTZ = NULL,
|
|
scheduled BOOL = true)
|
|
RETURNS INTEGER AS '@MODULE_PATHNAME@', 'ts_job_add' LANGUAGE C VOLATILE;
|
|
|
|
CREATE FUNCTION @extschema@.alter_job(
|
|
job_id INTEGER,
|
|
schedule_interval INTERVAL = NULL,
|
|
max_runtime INTERVAL = NULL,
|
|
max_retries INTEGER = NULL,
|
|
retry_period INTERVAL = NULL,
|
|
scheduled BOOL = NULL,
|
|
config JSONB = NULL,
|
|
next_start TIMESTAMPTZ = NULL,
|
|
if_exists BOOL = FALSE
|
|
)
|
|
RETURNS TABLE (job_id INTEGER, schedule_interval INTERVAL, max_runtime INTERVAL, max_retries INTEGER, retry_period INTERVAL, scheduled BOOL, config JSONB, next_start TIMESTAMPTZ)
|
|
AS '@MODULE_PATHNAME@', 'ts_job_alter'
|
|
LANGUAGE C VOLATILE;
|
|
|
|
DROP FUNCTION @extschema@.time_bucket(INTERVAL, TIMESTAMPTZ, TEXT, TIMESTAMPTZ, INTERVAL);
|
|
|
|
-- reverse cagg catalog relations
|
|
DROP PROCEDURE @extschema@.cagg_migrate (REGCLASS, BOOLEAN, BOOLEAN);
|
|
DROP FUNCTION _timescaledb_internal.cagg_migrate_pre_validation (TEXT, TEXT, TEXT);
|
|
DROP PROCEDURE _timescaledb_internal.cagg_migrate_create_plan (_timescaledb_catalog.continuous_agg, TEXT, BOOLEAN, BOOLEAN);
|
|
DROP FUNCTION _timescaledb_internal.cagg_migrate_plan_exists (INTEGER);
|
|
DROP PROCEDURE _timescaledb_internal.cagg_migrate_execute_plan (_timescaledb_catalog.continuous_agg);
|
|
DROP PROCEDURE _timescaledb_internal.cagg_migrate_execute_create_new_cagg (_timescaledb_catalog.continuous_agg, _timescaledb_catalog.continuous_agg_migrate_plan_step);
|
|
DROP PROCEDURE _timescaledb_internal.cagg_migrate_execute_disable_policies (_timescaledb_catalog.continuous_agg, _timescaledb_catalog.continuous_agg_migrate_plan_step);
|
|
DROP PROCEDURE _timescaledb_internal.cagg_migrate_execute_enable_policies (_timescaledb_catalog.continuous_agg, _timescaledb_catalog.continuous_agg_migrate_plan_step);
|
|
DROP PROCEDURE _timescaledb_internal.cagg_migrate_execute_copy_policies (_timescaledb_catalog.continuous_agg, _timescaledb_catalog.continuous_agg_migrate_plan_step);
|
|
DROP PROCEDURE _timescaledb_internal.cagg_migrate_execute_refresh_new_cagg (_timescaledb_catalog.continuous_agg, _timescaledb_catalog.continuous_agg_migrate_plan_step);
|
|
DROP PROCEDURE _timescaledb_internal.cagg_migrate_execute_copy_data (_timescaledb_catalog.continuous_agg, _timescaledb_catalog.continuous_agg_migrate_plan_step);
|
|
DROP PROCEDURE _timescaledb_internal.cagg_migrate_execute_override_cagg (_timescaledb_catalog.continuous_agg, _timescaledb_catalog.continuous_agg_migrate_plan_step);
|
|
DROP PROCEDURE _timescaledb_internal.cagg_migrate_execute_drop_old_cagg (_timescaledb_catalog.continuous_agg, _timescaledb_catalog.continuous_agg_migrate_plan_step);
|
|
|
|
ALTER EXTENSION timescaledb DROP SEQUENCE _timescaledb_catalog.continuous_agg_migrate_plan_step_step_id_seq;
|
|
ALTER EXTENSION timescaledb DROP TABLE _timescaledb_catalog.continuous_agg_migrate_plan_step;
|
|
DROP TABLE _timescaledb_catalog.continuous_agg_migrate_plan_step;
|
|
ALTER EXTENSION timescaledb DROP TABLE _timescaledb_catalog.continuous_agg_migrate_plan;
|
|
DROP TABLE _timescaledb_catalog.continuous_agg_migrate_plan;
|
|
|
|
DROP FUNCTION IF EXISTS @extschema@.create_hypertable(regclass,name,name,integer,name,name,anyelement,boolean,boolean,regproc,boolean,text,regproc,regproc,integer,name[],boolean);
|
|
DROP FUNCTION IF EXISTS @extschema@.create_distributed_hypertable(regclass,name,name,integer,name,name,anyelement,boolean,boolean,regproc,boolean,text,regproc,regproc,integer,name[]);
|
|
|
|
CREATE FUNCTION @extschema@.create_hypertable(
|
|
relation REGCLASS,
|
|
time_column_name NAME,
|
|
partitioning_column NAME = NULL,
|
|
number_partitions INTEGER = NULL,
|
|
associated_schema_name NAME = NULL,
|
|
associated_table_prefix NAME = NULL,
|
|
chunk_time_interval ANYELEMENT = NULL::bigint,
|
|
create_default_indexes BOOLEAN = TRUE,
|
|
if_not_exists BOOLEAN = FALSE,
|
|
partitioning_func REGPROC = NULL,
|
|
migrate_data BOOLEAN = FALSE,
|
|
chunk_target_size TEXT = NULL,
|
|
chunk_sizing_func REGPROC = '_timescaledb_internal.calculate_chunk_interval'::regproc,
|
|
time_partitioning_func REGPROC = NULL,
|
|
replication_factor INTEGER = NULL,
|
|
data_nodes NAME[] = NULL
|
|
) RETURNS TABLE(hypertable_id INT, schema_name NAME, table_name NAME, created BOOL) AS '@MODULE_PATHNAME@', 'ts_hypertable_create' LANGUAGE C VOLATILE;
|
|
|
|
CREATE FUNCTION @extschema@.create_distributed_hypertable(
|
|
relation REGCLASS,
|
|
time_column_name NAME,
|
|
partitioning_column NAME = NULL,
|
|
number_partitions INTEGER = NULL,
|
|
associated_schema_name NAME = NULL,
|
|
associated_table_prefix NAME = NULL,
|
|
chunk_time_interval ANYELEMENT = NULL::bigint,
|
|
create_default_indexes BOOLEAN = TRUE,
|
|
if_not_exists BOOLEAN = FALSE,
|
|
partitioning_func REGPROC = NULL,
|
|
migrate_data BOOLEAN = FALSE,
|
|
chunk_target_size TEXT = NULL,
|
|
chunk_sizing_func REGPROC = '_timescaledb_internal.calculate_chunk_interval'::regproc,
|
|
time_partitioning_func REGPROC = NULL,
|
|
replication_factor INTEGER = 1,
|
|
data_nodes NAME[] = NULL
|
|
) RETURNS TABLE(hypertable_id INT, schema_name NAME, table_name NAME, created BOOL) AS '@MODULE_PATHNAME@', 'ts_hypertable_distributed_create' LANGUAGE C VOLATILE;
|