postgres/timescaledb
1
0
Fork 0
mirror of https://github.com/timescale/timescaledb.git synced 2025-05-22 22:11:29 +08:00
Code Issues Packages Projects Releases Wiki Activity

remove dead code

Browse Source
This commit is contained in:
Matvey Arye 2016-11-07 12:02:34 -05:00
parent e96509d4c0
commit 117e5ccd47
3 changed files with 0 additions and 692 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

97
sql/main/insert_system.sql
View File

@ -1,97 +0,0 @@
CREATE OR REPLACE FUNCTION initialize_field_from_system_connector(
project_id INT,
namespace TEXT,
replica_no SMALLINT,
partition_number SMALLINT,
total_partitions SMALLINT,
field_name TEXT
)
RETURNS VOID LANGUAGE PLPGSQL VOLATILE AS
$BODY$
DECLARE
pfl project_field_local;
BEGIN
pfl = field_info_from_system_connector(project_id :: BIGINT, namespace, replica_no, field_name);
PERFORM create_field_from_definition(pfl.project_id, pfl.namespace, pfl.replica_no, pfl.field, pfl.is_distinct,
pfl.is_partition_key, pfl.value_type, pfl.idx_types);
END
$BODY$;
CREATE OR REPLACE FUNCTION register_field_from_system_connector(
project_id INT,
namespace TEXT,
replica_no SMALLINT,
partition_number SMALLINT,
total_partitions SMALLINT,
field_name TEXT
)
RETURNS VOID LANGUAGE PLPGSQL VOLATILE AS
$BODY$
DECLARE
pfl project_field_local;
BEGIN
pfl = field_info_from_system_connector(project_id :: BIGINT, namespace, replica_no, field_name);
PERFORM register_project_field(
pfl.project_id, pfl.namespace, pfl.replica_no, pfl.field,
pfl.value_type, pfl.is_partition_key, pfl.is_distinct, pfl.idx_types);
END
$BODY$;
CREATE OR REPLACE FUNCTION field_info_from_system_connector(
project_id BIGINT,
namespace TEXT,
replica_no SMALLINT,
field TEXT
)
RETURNS project_field_local LANGUAGE PLPGSQL VOLATILE AS
$BODY$
DECLARE
field_name TEXT;
field_type TEXT;
field_type_oid REGTYPE;
field_is_distinct BOOLEAN;
field_is_partitioning BOOLEAN;
index_type_string TEXT;
index_types field_index_type [];
BEGIN
SELECT
nsf.field,
nsf.type,
(lower(nl_distinct.value) IS NOT DISTINCT FROM 'true'),
ns.partitioning_field = nsf.field,
upper(nl_idx_type.value) :: field_index_type
INTO STRICT field_name, field_type, field_is_distinct, field_is_partitioning, index_type_string
FROM system.namespaces AS ns
INNER JOIN system.namespace_fields AS nsf ON (ns.namespace_id = nsf.namespace_id)
LEFT JOIN system.namespace_labels AS nl_distinct
ON (nl_distinct.namespace_id = ns.namespace_id AND nl_distinct.name = nsf.field || ':distinct')
LEFT JOIN system.namespace_labels AS nl_idx_type
ON (nl_idx_type.namespace_id = ns.namespace_id AND nl_idx_type.name = nsf.field || ':index_type')
WHERE
ns.project_id = field_info_from_system_connector.project_id AND
ns.name = field_info_from_system_connector.namespace AND
nsf.field = field_info_from_system_connector.field;
SELECT t :: REGTYPE
INTO field_type_oid
FROM get_field_type_from_ns_type(field_type) AS t;
index_types = string_to_array(index_type_string, ',') :: field_index_type [];
IF index_types IS NULL
THEN
IF field_is_distinct OR field_type_oid :: REGTYPE = 'TEXT' :: REGTYPE THEN
index_types = '{VALUE-TIME}'; --'{VALUE-TIME,TIME-VALUE}'
ELSE
index_types = '{TIME-VALUE}';
END IF;
END IF;
RETURN ROW (project_id, namespace, replica_no, field_name, field_type_oid, field_is_partitioning,
field_is_distinct, index_types, NULL :: TEXT);
END
$BODY$;

589
sql/main/ioql_unoptimized.sql
View File

@ -1,589 +0,0 @@
CREATE OR REPLACE FUNCTION get_cluster_name(namespace_type)
RETURNS TEXT LANGUAGE SQL IMMUTABLE AS
$BODY$
SELECT format($$cluster."%s_%s_%s"$$, $1.project_id, $1.name, $1.replica_no)
$BODY$;
CREATE OR REPLACE FUNCTION get_cluster_table(namespace_type)
RETURNS REGCLASS LANGUAGE SQL STABLE AS
$BODY$
SELECT get_cluster_name($1) :: REGCLASS
$BODY$;
CREATE OR REPLACE FUNCTION get_distinct_table_local(ns namespace_type)
RETURNS REGCLASS LANGUAGE SQL STABLE AS
$BODY$
SELECT get_distinct_table_oid(ns.name)
$BODY$;
CREATE OR REPLACE FUNCTION get_distinct_table_cluster(ns namespace_type)
RETURNS REGCLASS LANGUAGE SQL STABLE AS
$BODY$
SELECT ('cluster.' || table_name :: TEXT) :: REGCLASS
FROM get_distinct_table(ns.project_id, ns.name, ns.replica_no)
$BODY$;
CREATE OR REPLACE FUNCTION get_distinct_values_local(ns namespace_type, field TEXT)
RETURNS SETOF TEXT LANGUAGE PLPGSQL STABLE AS
$BODY$
DECLARE
table_name REGCLASS;
BEGIN
SELECT dis.table_name
INTO table_name
FROM distinct_tables dis
WHERE project_id = ns.project_id AND namespace = ns.name AND replica_no = ns.replica_no;
RETURN QUERY EXECUTE format(
$$
SELECT DISTINCT value
FROM %s
WHERE field = %L
$$,
table_name, field);
END
$BODY$;
CREATE OR REPLACE FUNCTION get_distinct_values_cluster(ns namespace_type, field TEXT)
RETURNS SETOF TEXT LANGUAGE PLPGSQL STABLE AS
$BODY$
BEGIN
RETURN QUERY EXECUTE format(
$$
SELECT DISTINCT value
FROM %s
WHERE field = %L
$$,
get_distinct_table_cluster(ns), field);
END
$BODY$;
CREATE OR REPLACE FUNCTION get_field_is_distinct(ns namespace_type, field_name TEXT)
RETURNS BOOLEAN LANGUAGE PLPGSQL STABLE STRICT AS
$BODY$
DECLARE
field_is_distinct BOOLEAN;
BEGIN
SELECT DISTINCT is_distinct
INTO STRICT field_is_distinct
FROM cluster.project_field pf
WHERE
pf.project_id = ns.project_id AND
pf.namespace = ns.name AND
pf.field = field_name;
RETURN field_is_distinct;
EXCEPTION
WHEN NO_DATA_FOUND THEN
RAISE EXCEPTION 'Field is_distinct not found. Field name: % namespace: %', field_name, ns;
END
$BODY$;
CREATE OR REPLACE FUNCTION get_field_type(ns namespace_type, field_name TEXT)
RETURNS REGTYPE LANGUAGE PLPGSQL STABLE STRICT AS
$BODY$
DECLARE
field_type REGTYPE;
BEGIN
SELECT DISTINCT value_type
INTO STRICT field_type
FROM cluster.project_field pf
WHERE
pf.project_id = ns.project_id AND
pf.namespace = ns.name AND
pf.field = field_name;
RETURN field_type;
EXCEPTION
WHEN NO_DATA_FOUND THEN
RAISE EXCEPTION 'Field type not found. Field name: % namespace: %', field_name, ns;
END
$BODY$;
CREATE OR REPLACE FUNCTION get_field_value_specifier(field_name TEXT)
RETURNS TEXT LANGUAGE SQL IMMUTABLE STRICT AS
$BODY$
SELECT format('%I', field_name);
$BODY$;
CREATE OR REPLACE FUNCTION get_field_value_specifier(ns namespace_type, field_name TEXT)
RETURNS TEXT LANGUAGE SQL IMMUTABLE STRICT AS
$BODY$
SELECT get_field_value_specifier(field_name)
$BODY$;
CREATE OR REPLACE FUNCTION is_partition_key(ns namespace_type, field_name TEXT)
RETURNS BOOLEAN LANGUAGE PLPGSQL STABLE STRICT AS
$BODY$
DECLARE
ret BOOLEAN;
BEGIN
SELECT DISTINCT is_partition_key
INTO STRICT ret
FROM cluster.project_field pf
WHERE
pf.project_id = ns.project_id AND
pf.namespace = ns.name AND
pf.field = field_name;
RETURN ret;
EXCEPTION
WHEN NO_DATA_FOUND THEN
RAISE EXCEPTION 'Field is_partition_key not found. Field name: % namespace: %', field_name, ns;
END
$BODY$;
CREATE OR REPLACE FUNCTION get_field_name_clause(select_field TEXT)
RETURNS TEXT LANGUAGE SQL STABLE AS
$BODY$
SELECT CASE WHEN select_field IS NOT NULL AND select_field <> '*' THEN select_field END;
$BODY$;
CREATE OR REPLACE FUNCTION get_group_field_clause(ns namespace_type, group_field TEXT)
RETURNS TEXT LANGUAGE SQL STABLE AS
$BODY$
SELECT CASE WHEN group_field IS NOT NULL THEN get_field_value_specifier(ns, group_field)
ELSE 'NULL' END;
$BODY$;
CREATE OR REPLACE FUNCTION get_value_clause(ns namespace_type, select_field TEXT, op TEXT)
RETURNS TEXT LANGUAGE SQL STABLE AS
$BODY$
SELECT CASE WHEN op IS NULL THEN
CASE WHEN select_field = '*' THEN 'value'
ELSE format('jsonb_build_object(%L, %s)', select_field, get_field_value_specifier(ns, select_field))
END
ELSE
format('%s(%s)', op, get_field_value_specifier(ns, select_field))
END;
$BODY$;
CREATE OR REPLACE FUNCTION get_value_type(ns namespace_type, select_field TEXT, op TEXT)
RETURNS REGTYPE LANGUAGE SQL STABLE AS
$BODY$
SELECT CASE WHEN op IS NULL THEN
CASE WHEN select_field = '*' THEN 'jsonb' :: REGTYPE
ELSE get_field_type(ns, select_field)
END
ELSE
'double precision' :: REGTYPE
END;
$BODY$;
CREATE OR REPLACE FUNCTION get_value_type_clause(ns namespace_type, select_field TEXT, op TEXT)
RETURNS TEXT LANGUAGE SQL STABLE AS
$BODY$
SELECT format('%L::regtype', get_value_type(ns, select_field, op) :: TEXT);
$BODY$;
CREATE OR REPLACE FUNCTION get_time_clause(group_time BIGINT)
RETURNS TEXT LANGUAGE SQL IMMUTABLE AS
$BODY$
SELECT CASE WHEN group_time IS NOT NULL THEN format('(time - (time %% %L::bigint))::bigint', group_time)
ELSE 'time' END;
$BODY$;
CREATE OR REPLACE FUNCTION get_group_field_clause(ns namespace_type, op TEXT, group_field TEXT)
RETURNS TEXT LANGUAGE SQL STABLE AS $BODY$
SELECT CASE WHEN op IS NOT NULL THEN get_field_value_specifier(ns, group_field)
ELSE 'NULL' END;
$BODY$;
CREATE OR REPLACE FUNCTION get_full_select_clause(ns namespace_type, query ioql_query)
RETURNS TEXT LANGUAGE SQL STABLE AS
$BODY$
SELECT format('SELECT time, %s', get_field_list(query));
$BODY$;
CREATE OR REPLACE FUNCTION get_time_predicate(cond time_condition_type)
RETURNS TEXT LANGUAGE SQL IMMUTABLE AS
$BODY$
SELECT string_agg(clauses.val, ' AND ')
FROM (VALUES ('time>=' || cond.from_time), ('time<' || cond.to_time)) AS clauses(val);
$BODY$;
CREATE OR REPLACE FUNCTION get_select_field_required_field(select_field select_item [])
RETURNS SETOF TEXT LANGUAGE SQL IMMUTABLE AS
$BODY$
SELECT CASE WHEN select_field <> NULL THEN
(SELECT field
FROM unnest(select_field))
END;
$BODY$;
CREATE OR REPLACE FUNCTION get_field_condition_required_fields(cond field_condition_type)
RETURNS SETOF TEXT LANGUAGE SQL IMMUTABLE STRICT AS $BODY$
SELECT p.field
FROM unnest(cond.predicates) AS p
WHERE cond.conjunctive = 'AND'
$BODY$;
CREATE OR REPLACE FUNCTION get_required_fields(query ioql_query)
RETURNS SETOF TEXT LANGUAGE SQL IMMUTABLE STRICT AS
$BODY$
(
SELECT *
FROM get_field_condition_required_fields(query.field_condition)
)
UNION
(
SELECT *
FROM get_select_field_required_field(query.select_field) f
WHERE f IS NOT NULL
)
$BODY$;
CREATE OR REPLACE FUNCTION get_partitioning_predicate(ns namespace_type,
partitioning_field_value TEXT,
total_partitions INT)
RETURNS TEXT LANGUAGE SQL IMMUTABLE STRICT AS
$BODY$
SELECT format('get_partition_for_key(%I, %L) = %L', get_partitioning_field(ns.project_id :: INT, ns.name),
total_partitions, get_partition_for_key(partitioning_field_value, total_partitions))
$BODY$;
CREATE OR REPLACE FUNCTION get_partitioning_field_value(ns namespace_type, cond field_condition_type)
RETURNS TEXT LANGUAGE SQL STABLE STRICT AS
$BODY$
SELECT p.constant
FROM unnest(cond.predicates) AS p
WHERE is_partition_key(ns, p.field) AND cond.conjunctive = 'AND' AND p.op = '='
$BODY$;
CREATE OR REPLACE FUNCTION combine_predicates(VARIADIC clauses TEXT [])
RETURNS TEXT LANGUAGE SQL IMMUTABLE AS
$BODY$
SELECT string_agg(clause.val, ' AND ')
FROM unnest(clauses) AS clause(val);
$BODY$;
CREATE OR REPLACE FUNCTION get_where_clause(VARIADIC clauses TEXT [])
RETURNS TEXT LANGUAGE SQL IMMUTABLE AS
$BODY$
SELECT coalesce('WHERE ' || combine_predicates(VARIADIC clauses), '');
$BODY$;
CREATE OR REPLACE FUNCTION get_json_aggregate_field_key(agg aggregate_type, select_i select_item)
RETURNS TEXT LANGUAGE SQL IMMUTABLE AS
$BODY$
SELECT format('%s(%s)', lower(select_i.func :: TEXT), select_i.field);
$BODY$;
--
CREATE OR REPLACE FUNCTION get_groupby_clause(ns namespace_type, agg aggregate_type)
RETURNS TEXT LANGUAGE SQL IMMUTABLE AS
$BODY$
SELECT get_groupby_clause(agg);
$BODY$;
CREATE OR REPLACE FUNCTION get_limit_clause(limit_count INT)
RETURNS TEXT LANGUAGE SQL IMMUTABLE AS
$BODY$
SELECT 'LIMIT ' || limit_count
$BODY$;
CREATE OR REPLACE FUNCTION get_agg_orderby_clause(query ioql_query, time_col TEXT = 'group_time')
RETURNS TEXT LANGUAGE SQL IMMUTABLE AS
$BODY$
SELECT CASE
WHEN query.limit_rows IS NULL THEN
NULL --no need to order if not gonna limit
WHEN (query.aggregate).group_field IS NOT NULL THEN
format('ORDER BY %s DESC NULLS LAST, %s', time_col,
(query.aggregate).group_field) --group field needs to be included so that 5 aggregates across partitions overlap
ELSE
format('ORDER BY %s DESC NULLS LAST', time_col)
END;
$BODY$;
CREATE OR REPLACE FUNCTION get_orderby_clause(query ioql_query)
RETURNS TEXT LANGUAGE SQL IMMUTABLE AS
$BODY$
SELECT CASE
WHEN query.limit_by_field IS NOT NULL THEN
'ORDER BY time DESC NULLS LAST, ' || (query.limit_by_field).field
ELSE
'ORDER BY time DESC NULLS LAST'
END;
$BODY$;
CREATE OR REPLACE FUNCTION base_query_raw(select_clause TEXT, from_clause TEXT, where_clause TEXT,
group_by_clause TEXT, order_by_clause TEXT, limit_clause TEXT)
RETURNS TEXT LANGUAGE SQL IMMUTABLE AS
$BODY$
SELECT format(
$$
%s
%s
%s
%s
%s
%s
$$,
select_clause,
from_clause,
where_clause,
group_by_clause,
order_by_clause,
limit_clause
);
$BODY$;
CREATE OR REPLACE FUNCTION base_query_builder(query ioql_query, data_table REGCLASS,
additional_constraints TEXT, select_clause TEXT, limit_clause TEXT,
total_partitions INT = NULL)
RETURNS TEXT LANGUAGE PLPGSQL STABLE AS
$BODY$
DECLARE
ns namespace_type;
from_clause TEXT;
BEGIN
ns := ROW (query.project_id, query.namespace_name, 1);
from_clause := format('FROM %s', data_table);
RETURN base_query_raw(
select_clause,
from_clause,
get_where_clause(
default_predicates(ns, query, total_partitions),
additional_constraints
--get_required_fields_predicate(data_table, query) --this may be run on parent tables
),
get_groupby_clause(ns, query.aggregate),
get_orderby_clause(query),
limit_clause);
END
$BODY$;
CREATE OR REPLACE FUNCTION base_query(query ioql_query, data_table REGCLASS, additional_constraints TEXT DEFAULT NULL)
RETURNS TEXT LANGUAGE PLPGSQL STABLE AS
$BODY$
DECLARE
ns namespace_type;
select_clause TEXT;
BEGIN
ns := ROW (query.project_id, query.namespace_name, 1);
RETURN base_query_builder(query, data_table, additional_constraints, get_full_select_clause(ns, query),
get_limit_clause(query.limit_rows));
END
$BODY$;
CREATE OR REPLACE FUNCTION limit_by_every_query_nonagg(query ioql_query, data_table REGCLASS)
RETURNS TEXT LANGUAGE PLPGSQL STABLE AS
$BODY$
DECLARE
ns namespace_type;
query_sql TEXT;
BEGIN
ns := ROW (query.project_id, query.namespace_name, 1);
query_sql = format(
$$
SELECT namespace, field_name, group_field, ret_time, ret_value, value_type
FROM
(
SELECT ROW_NUMBER() OVER (PARTITION BY group_field ORDER BY ret_time DESC NULLS LAST, ret_value) as rank, *
FROM
(
%1$s
) as res
) as o
WHERE rank <= %2$L and get_field_is_distinct(%4$L, %5$L)
ORDER BY ret_time DESC NULLS LAST, group_field
%3$s
$$,
base_query_builder(
query,
data_table,
NULL,
format(
$$
SELECT %L::text as namespace,
%L::text as field_name,
%s::text as group_field,
%s::bigint as ret_time,
%s::text as ret_value,
%s::regtype value_type
$$,
query.namespace_name,
get_field_name_clause(query.select_field),
get_field_value_specifier(ns, (query.limit_by_field).field),
get_time_clause((query.aggregate).group_time),
get_value_clause(ns, query.select_field, (query.aggregate).func),
get_value_type_clause(ns, query.select_field, (query.aggregate).func)
),
NULL
),
(query.limit_by_field).count,
get_limit_clause(query.limit_rows),
ns,
(query.limit_by_field).field
);
RETURN query_sql;
END
$BODY$;
CREATE OR REPLACE FUNCTION group_field_agg(query ioql_query,
data_table REGCLASS,
additional_constraints TEXT DEFAULT NULL)
RETURNS TEXT LANGUAGE PLPGSQL STABLE AS
$BODY$
DECLARE
ns namespace_type;
query_sql TEXT;
BEGIN
ns := ROW (query.project_id, query.namespace_name, 1);
query_sql = format(
$$
SELECT %6$L::text, %7$L::text, res.group_field as group_field, res.ret_time, res.ret_value, res.value_type
FROM
(
%3$s
) AS res
%5$s
$$,
data_table,
(query.aggregate).group_field,
base_query(query, data_table, additional_constraints),
ns,
get_limit_clause(query.limit_rows),
query.namespace_name,
get_field_name_clause(query.select_field)
);
RETURN query_sql;
END
$BODY$;
CREATE OR REPLACE FUNCTION agg_query_number_time_periods_agg(query ioql_query, data_table REGCLASS)
RETURNS TEXT LANGUAGE PLPGSQL STABLE AS
$BODY$
DECLARE
ns namespace_type;
query_sql TEXT;
BEGIN
ns := ROW (query.project_id, query.namespace_name, 1);
query_sql = format(
$$
SELECT res.*
FROM
(
SELECT periods.*
FROM %3$s as dt,
get_time_periods_limit_for_max(dt.time, %1$L, %2$L) as periods
%4$s
ORDER BY time DESC LIMIT 1
) as time_range,
LATERAL (%5$s) res
$$,
(query.aggregate).group_time,
query.limit_time_periods,
data_table,
get_where_clause(default_predicates(ns, query)),
agg_query_regular_limit(query, data_table,
format('time <= time_range.end_time AND time >= time_range.start_time'))
);
RETURN query_sql;
END
$BODY$;
CREATE OR REPLACE FUNCTION agg_query_regular_limit(query ioql_query, data_table REGCLASS,
additional_constraint TEXT DEFAULT NULL)
RETURNS TEXT LANGUAGE SQL STABLE AS $BODY$
SELECT CASE
WHEN (query.aggregate).group_field IS NOT NULL THEN group_field_agg(query, data_table, additional_constraint)
ELSE base_query(query, data_table, additional_constraint)
END;
$BODY$;
CREATE OR REPLACE FUNCTION agg_query(query ioql_query, data_table REGCLASS)
RETURNS TEXT LANGUAGE SQL STABLE AS
$BODY$
SELECT CASE
WHEN query.limit_time_periods IS NOT NULL THEN
agg_query_number_time_periods_agg(query, data_table)
ELSE
agg_query_regular_limit(query, data_table)
END;
$BODY$;
CREATE OR REPLACE FUNCTION get_json_build_object_sql(query ioql_query)
RETURNS TEXT LANGUAGE SQL STABLE AS
$BODY$
SELECT ' jsonb_build_object( ' ||
string_agg(
get_json_aggregate_field_key(query.aggregate, i) || ', ' || i.field,
', '
) || ')'
FROM unnest(query.select_field) AS i
$BODY$;
CREATE OR REPLACE FUNCTION full_query(query ioql_query, data_table REGCLASS)
RETURNS TEXT LANGUAGE SQL STABLE AS
$BODY$
SELECT CASE
WHEN NOT (query.aggregate IS NULL) THEN
CASE
WHEN (query.aggregate).group_field IS NOT NULL THEN
format(
$$
SELECT
namespace,
field_name,
group_field,
ret_time,
%s:text,
return_value_type
FROM (%s) as nj(namespace, field_name, group_field, ret_time, ret_value, return_value_type)
ORDER BY ret_time DESC NULLS LAST, group_field
$$,
(query.aggregate).group_field, get_json_build_object_sql(query), agg_query(query, data_table))
ELSE
format(
$$
SELECT namespace, field_name, group_field, ret_time, %s::text, return_value_type
FROM (%s) as nj(namespace, field_name, group_field, ret_time, ret_value, return_value_type)
ORDER BY ret_time DESC NULLS LAST, group_field
$$,
get_json_build_object_sql(query), agg_query(query, data_table))
END
WHEN query.limit_by_field IS NOT NULL THEN
limit_by_every_query_nonagg(query, data_table)
ELSE
base_query(query, data_table)
END;
$BODY$;
CREATE OR REPLACE FUNCTION ioql_exec_query_unoptimized(query ioql_query)
RETURNS TABLE(json TEXT) LANGUAGE PLPGSQL STABLE AS
$BODY$
BEGIN
IF to_regclass(get_cluster_name(get_namespace(query)) :: cstring) IS NULL THEN
RETURN QUERY SELECT *
FROM no_cluster_table(query);
RETURN;
END IF;
RAISE NOTICE 'Cross-node query %', full_query(query, get_cluster_table(get_namespace(query)));
RETURN QUERY EXECUTE full_query(query, get_cluster_table(get_namespace(query)));
END
$BODY$;

6
sql/main/util.sql
View File

@ -1,6 +0,0 @@
CREATE OR REPLACE FUNCTION get_hostname()
RETURNS TEXT LANGUAGE SQL STABLE AS
$BODY$
SELECT current_setting('iobeam.hostname');
$BODY$;