text: -- This file and its contents are licensed under the Apache License 2.0.
  -- Please see the included NOTICE for copyright information and
  -- LICENSE-APACHE for a copy of the license.
  
  -- This file defines DDL functions for adding and manipulating hypertables.
  
  -- Converts a regular postgres table to a hypertable.
  --
  -- relation - The OID of the table to be converted
  -- time_column_name - Name of the column that contains time for a given record
  -- partitioning_column - Name of the column to partition data by
  -- number_partitions - (Optional) Number of partitions for data
  -- associated_schema_name - (Optional) Schema for internal hypertable tables
  -- associated_table_prefix - (Optional) Prefix for internal hypertable table names
  -- chunk_time_interval - (Optional) Initial time interval for a chunk
  -- create_default_indexes - (Optional) Whether or not to create the default indexes
  -- if_not_exists - (Optional) Do not fail if table is already a hypertable
  -- partitioning_func - (Optional) The partitioning function to use for spatial partitioning
  -- migrate_data - (Optional) Set to true to migrate any existing data in the table to chunks
  -- chunk_target_size - (Optional) The target size for chunks (e.g., '1000MB', 'estimate', or 'off')
  -- chunk_sizing_func - (Optional) A function to calculate the chunk time interval for new chunks
  -- time_partitioning_func - (Optional) The partitioning function to use for "time" partitioning
  -- replication_factor - (Optional) A value of 1 or greater makes this hypertable distributed
  -- data_nodes - (Optional) The specific data nodes to distribute this hypertable across
  CREATE OR REPLACE FUNCTION  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;
  
  -- Same functionality as create_hypertable, only must have a replication factor > 0 (defaults to 1)
  CREATE OR REPLACE FUNCTION  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;
  
  -- Set adaptive chunking. To disable, set chunk_target_size => 'off'.
  CREATE OR REPLACE FUNCTION  set_adaptive_chunking(
      hypertable                     REGCLASS,
      chunk_target_size              TEXT,
      INOUT chunk_sizing_func        REGPROC = '_timescaledb_internal.calculate_chunk_interval'::regproc,
      OUT chunk_target_size          BIGINT
  ) RETURNS RECORD AS '@MODULE_PATHNAME@', 'ts_chunk_adaptive_set' LANGUAGE C VOLATILE;
  
  -- Update chunk_time_interval for a hypertable.
  --
  -- hypertable - The OID of the table corresponding to a hypertable whose time
  --     interval should be updated
  -- chunk_time_interval - The new time interval. For hypertables with integral
  --     time columns, this must be an integral type. For hypertables with a
  --     TIMESTAMP/TIMESTAMPTZ/DATE type, it can be integral which is treated as
  --     microseconds, or an INTERVAL type.
  CREATE OR REPLACE FUNCTION  set_chunk_time_interval(
      hypertable              REGCLASS,
      chunk_time_interval     ANYELEMENT,
      dimension_name          NAME = NULL
  ) RETURNS VOID AS '@MODULE_PATHNAME@', 'ts_dimension_set_interval' LANGUAGE C VOLATILE;
  
  CREATE OR REPLACE FUNCTION  set_number_partitions(
      hypertable              REGCLASS,
      number_partitions       INTEGER,
      dimension_name          NAME = NULL
  ) RETURNS VOID AS '@MODULE_PATHNAME@', 'ts_dimension_set_num_slices' LANGUAGE C VOLATILE;
  
  -- Drop chunks older than the given timestamp for the specific
  -- hypertable or continuous aggregate.
  CREATE OR REPLACE FUNCTION drop_chunks(
      relation               REGCLASS,
      older_than             "any" = NULL,
      newer_than             "any" = NULL,
      verbose                BOOLEAN = FALSE
  ) RETURNS SETOF TEXT AS '@MODULE_PATHNAME@', 'ts_chunk_drop_chunks'
  LANGUAGE C VOLATILE PARALLEL UNSAFE;
  
  -- show chunks older than or newer than a specific time.
  -- `relation` must be a valid hypertable or continuous aggregate.
  CREATE OR REPLACE FUNCTION show_chunks(
      relation               REGCLASS,
      older_than             "any" = NULL,
      newer_than             "any" = NULL
  ) RETURNS SETOF REGCLASS AS '@MODULE_PATHNAME@', 'ts_chunk_show_chunks'
  LANGUAGE C STABLE PARALLEL SAFE;
  
  -- Add a dimension (of partitioning) to a hypertable
  --
  -- hypertable - OID of the table to add a dimension to
  -- column_name - NAME of the column to use in partitioning for this dimension
  -- number_partitions - Number of partitions, for non-time dimensions
  -- interval_length - Size of intervals for time dimensions (can be integral or INTERVAL)
  -- partitioning_func - Function used to partition the column
  -- if_not_exists - If set, and the dimension already exists, generate a notice instead of an error
  CREATE OR REPLACE FUNCTION  add_dimension(
      hypertable              REGCLASS,
      column_name             NAME,
      number_partitions       INTEGER = NULL,
      chunk_time_interval     ANYELEMENT = NULL::BIGINT,
      partitioning_func       REGPROC = NULL,
      if_not_exists           BOOLEAN = FALSE
  ) RETURNS TABLE(dimension_id INT, schema_name NAME, table_name NAME, column_name NAME, created BOOL)
  AS '@MODULE_PATHNAME@', 'ts_dimension_add' LANGUAGE C VOLATILE;
  
  CREATE OR REPLACE FUNCTION attach_tablespace(
      tablespace NAME,
      hypertable REGCLASS,
      if_not_attached BOOLEAN = false
  ) RETURNS VOID
  AS '@MODULE_PATHNAME@', 'ts_tablespace_attach' LANGUAGE C VOLATILE;
  
  CREATE OR REPLACE FUNCTION detach_tablespace(
      tablespace NAME,
      hypertable REGCLASS = NULL,
      if_attached BOOLEAN = false
  ) RETURNS INTEGER
  AS '@MODULE_PATHNAME@', 'ts_tablespace_detach' LANGUAGE C VOLATILE;
  
  CREATE OR REPLACE FUNCTION detach_tablespaces(hypertable REGCLASS) RETURNS INTEGER
  AS '@MODULE_PATHNAME@', 'ts_tablespace_detach_all_from_hypertable' LANGUAGE C VOLATILE;
  
  CREATE OR REPLACE FUNCTION show_tablespaces(hypertable REGCLASS) RETURNS SETOF NAME
  AS '@MODULE_PATHNAME@', 'ts_tablespace_show' LANGUAGE C VOLATILE STRICT;
  
  -- Add a data node to a TimescaleDB distributed database.
  CREATE OR REPLACE FUNCTION add_data_node(
      node_name              NAME,
      host                   TEXT,
      database               NAME = NULL,
      port                   INTEGER = NULL,
      if_not_exists          BOOLEAN = FALSE,
      bootstrap              BOOLEAN = TRUE,
      password               TEXT = NULL
  ) RETURNS TABLE(node_name NAME, host TEXT, port INTEGER, database NAME,
                  node_created BOOL, database_created BOOL, extension_created BOOL)
  AS '@MODULE_PATHNAME@', 'ts_data_node_add' LANGUAGE C VOLATILE;
  
  -- Delete a data node from a distributed database
  CREATE OR REPLACE FUNCTION delete_data_node(
      node_name              NAME,
      if_exists              BOOLEAN = FALSE,
      force                  BOOLEAN = FALSE,
      repartition            BOOLEAN = TRUE
  ) RETURNS BOOLEAN AS '@MODULE_PATHNAME@', 'ts_data_node_delete' LANGUAGE C VOLATILE;
  
  -- Attach a data node to a distributed hypertable
  CREATE OR REPLACE FUNCTION attach_data_node(
      node_name              NAME,
      hypertable             REGCLASS,
      if_not_attached        BOOLEAN = FALSE,
      repartition            BOOLEAN = TRUE
  ) RETURNS TABLE(hypertable_id INTEGER, node_hypertable_id INTEGER, node_name NAME)
  AS '@MODULE_PATHNAME@', 'ts_data_node_attach' LANGUAGE C VOLATILE;
  
  -- Detach a data node from a distributed hypertable. NULL hypertable means it will detach from all distributed hypertables
  CREATE OR REPLACE FUNCTION 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;
  
  -- Execute query on a specified list of data nodes. By default node_list is NULL, which means
  -- to execute the query on every data node
  CREATE OR REPLACE PROCEDURE distributed_exec(
         query TEXT,
         node_list name[] = NULL,
         transactional BOOLEAN = TRUE)
  AS '@MODULE_PATHNAME@', 'ts_distributed_exec' LANGUAGE C;
  
  -- Execute pg_create_restore_point() on each data node
  CREATE OR REPLACE FUNCTION create_distributed_restore_point(
      name                   TEXT
  ) RETURNS TABLE(node_name NAME, node_type TEXT, restore_point pg_lsn)
  AS '@MODULE_PATHNAME@', 'ts_create_distributed_restore_point' LANGUAGE C VOLATILE STRICT;
  
  -- Sets new replication factor for distributed hypertable
  CREATE OR REPLACE FUNCTION  set_replication_factor(
      hypertable              REGCLASS,
      replication_factor      INTEGER
  ) RETURNS VOID
  AS '@MODULE_PATHNAME@', 'ts_hypertable_distributed_set_replication_factor' LANGUAGE C VOLATILE;
  
  -- Refresh a continuous aggregate across the given window.
  CREATE OR REPLACE PROCEDURE refresh_continuous_aggregate(
      continuous_aggregate     REGCLASS,
      window_start             "any",
      window_end               "any"
  ) LANGUAGE C AS '@MODULE_PATHNAME@', 'ts_continuous_agg_refresh';
  