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

Merged in remove-namespace (pull request #35)

Browse Source
This commit is contained in:
RobAtticus NA 2017-01-19 17:29:30 +00:00
commit 564c4f2bbe
22 changed files with 216 additions and 236 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
extension/sql/common/errors.sql
View File

@ -2,12 +2,12 @@
-- PREFIX IO
-- IO000 - GROUP: query errors
-- IO001 - namespace does not exist
-- IO001 - hypertable does not exist
-- IO002 - field does not exist
--IO100 - GROUP: DDL errors
--IO101 - operation not supported
--IO102 - no partitioning field for namespace
--IO102 - no partitioning field for hypertable
--IO103 - unknown index type
--IO104 - illegal name/identifier.

40
extension/sql/main/ioql.sql
View File

@ -22,7 +22,7 @@ BEGIN
--Grouptime is in usec if timestamp type used for time column in the data.
--If time is numeric, unit used by grouptime needs to match units in the data inserted
--(this is determined by user: inserted data can be in sec, usec, nanosec, etc.).
CREATE TYPE aggregate_type AS (group_time BIGINT, group_field TEXT);
CREATE TYPE aggregate_type AS (group_time BIGINT, group_field TEXT);
CREATE TYPE field_condition_type AS (conjunctive predicate_conjunctive, predicates field_predicate []);
@ -32,19 +32,19 @@ BEGIN
CREATE TYPE time_condition_type AS (from_time BIGINT, to_time BIGINT); --from_time inclusive; to_time exclusive
CREATE TYPE ioql_query AS (
namespace_name TEXT, -- NOT NULL
select_items select_item [], -- NULL to return row, not null for aggregating
aggregate aggregate_type, --op, group_field and group_time
time_condition time_condition_type, --time limits, from and to
field_condition field_condition_type, -- field predicates combined with a conjunctive (AND/OR)
limit_rows INT, --regular limit (number of rows)
limit_time_periods INT, --limit # of time periods, only aggregates
limit_by_field limit_by_field_type -- limit by every field value, only non-aggregate; field must be distinct
hypertable_name TEXT, -- NOT NULL
select_items select_item [], -- NULL to return row, not null for aggregating
aggregate aggregate_type, --op, group_field and group_time
time_condition time_condition_type, --time limits, from and to
field_condition field_condition_type, -- field predicates combined with a conjunctive (AND/OR)
limit_rows INT, --regular limit (number of rows)
limit_time_periods INT, --limit # of time periods, only aggregates
limit_by_field limit_by_field_type -- limit by every field value, only non-aggregate; field must be distinct
);
CREATE TYPE time_range AS (start_time BIGINT, end_time BIGINT);
CREATE TYPE namespace_partition_type AS (namespace_name NAME, partition_number SMALLINT, total_partitions SMALLINT);
CREATE TYPE hypertable_partition_type AS (hypertable_name NAME, partition_number SMALLINT, total_partitions SMALLINT);
END IF;
END
$CREATETYPES$;
@ -53,19 +53,19 @@ $CREATETYPES$;
---------------------------------------------
CREATE OR REPLACE FUNCTION new_ioql_query(
namespace_name TEXT, -- NOT NULL
select_items select_item [] = NULL,
aggregate aggregate_type = NULL, --op, group_field and group_time for aggregation, if NULL, not aggregating
time_condition time_condition_type = NULL, --time limits, from and to
field_condition field_condition_type = NULL, -- field predicates combined with a conjunctive (AND/OR)
limit_rows INT = NULL, --regular limit (number of rows)
limit_time_periods INT = NULL, --limit # of time periods, only aggregates
limit_by_field limit_by_field_type = NULL-- limit by every field value, only non-aggregate; field must be distinct
hypertable_name TEXT, -- NOT NULL
select_items select_item [] = NULL,
aggregate aggregate_type = NULL, --op, group_field and group_time for aggregation, if NULL, not aggregating
time_condition time_condition_type = NULL, --time limits, from and to
field_condition field_condition_type = NULL, -- field predicates combined with a conjunctive (AND/OR)
limit_rows INT = NULL, --regular limit (number of rows)
limit_time_periods INT = NULL, --limit # of time periods, only aggregates
limit_by_field limit_by_field_type = NULL-- limit by every field value, only non-aggregate; field must be distinct
)
RETURNS ioql_query AS $BODY$
--TODO convert empty select_item to NULL?
SELECT ROW (
namespace_name,
hypertable_name,
select_items,
aggregate,
time_condition,
@ -125,5 +125,3 @@ CREATE OR REPLACE FUNCTION new_limit_by_field(
RETURNS limit_by_field_type AS $BODY$
SELECT ROW (field, count) :: limit_by_field_type
$BODY$ LANGUAGE 'sql' STABLE;

4
extension/sql/main/ioql_errors.sql
View File

@ -2,7 +2,7 @@ CREATE OR REPLACE FUNCTION no_cluster_table(query ioql_query)
RETURNS TABLE(json TEXT) LANGUAGE PLPGSQL STABLE AS
$BODY$
BEGIN
RAISE EXCEPTION 'Namespace ''%'' does not exist', query.namespace_name
RAISE EXCEPTION 'Hypertable ''%'' does not exist', query.hypertable_name
USING ERRCODE = 'IO001';
END
$BODY$;
$BODY$;

15
extension/sql/main/ioql_optimized.sql
View File

@ -5,8 +5,8 @@ DECLARE
sql_code TEXT;
inner_sql TEXT;
BEGIN
--TODO : cross-epoch queries can be optimized much more than a simple limit.
SELECT code_epoch.code
--TODO : cross-epoch queries can be optimized much more than a simple limit.
SELECT code_epoch.code
INTO inner_sql
FROM (
SELECT CASE WHEN NOT query.aggregate IS NULL THEN
@ -15,11 +15,11 @@ BEGIN
ioql_query_nonagg_sql(query, pe)
END AS code
FROM partition_epoch pe
WHERE pe.hypertable_name = query.namespace_name
WHERE pe.hypertable_name = query.hypertable_name
) AS code_epoch;
IF NOT FOUND THEN
PERFORM no_cluster_table(query);
PERFORM no_cluster_table(query);
END IF;
SELECT format(
@ -49,10 +49,6 @@ LANGUAGE plpgsql STABLE;
CREATE OR REPLACE FUNCTION ioql_exec_query(query ioql_query)
RETURNS TABLE(json TEXT) 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;
RETURN QUERY EXECUTE format(
$$
SELECT row_to_json(ans)::text
@ -61,6 +57,3 @@ BEGIN
END
$BODY$
LANGUAGE plpgsql STABLE;

23
extension/sql/main/ioql_optimized_agg.sql
View File

@ -146,11 +146,11 @@ CREATE OR REPLACE FUNCTION get_partial_aggregate_column_def(query ioql_query)
SELECT CASE
WHEN (query.aggregate).group_field IS NOT NULL THEN
format('%I %s, group_time %s, %s', (query.aggregate).group_field,
get_field_type(query.namespace_name, (query.aggregate).group_field),
get_time_field_type(query.namespace_name),
get_field_type(query.hypertable_name, (query.aggregate).group_field),
get_time_field_type(query.hypertable_name),
field_list)
ELSE
format('group_time %s, %s', get_time_field_type(query.namespace_name), field_list)
format('group_time %s, %s', get_time_field_type(query.hypertable_name), field_list)
END
FROM
(
@ -217,7 +217,7 @@ DECLARE
BEGIN
select_clause :=
'SELECT ' || get_partial_aggregate_sql(get_time_field(query.namespace_name), get_time_field_type(query.namespace_name), query.select_items, query.aggregate);
'SELECT ' || get_partial_aggregate_sql(get_time_field(query.hypertable_name), get_time_field_type(query.hypertable_name), query.select_items, query.aggregate);
RETURN base_query_raw(
select_clause,
@ -435,7 +435,7 @@ SELECT format('SELECT * FROM (%s) as combined_node ',
coalesce(
string_agg(code_part, ' UNION ALL '),
format('SELECT %s WHERE FALSE',
get_combine_partial_aggregate_zero_value_sql(get_time_field_type(query.namespace_name), query.select_items, query.aggregate))
get_combine_partial_aggregate_zero_value_sql(get_time_field_type(query.hypertable_name), query.select_items, query.aggregate))
))
-- query.limit_rows + 1, needed since a group can span across time. +1 guarantees group was closed
FROM
@ -477,16 +477,16 @@ DECLARE
time_col_type regtype;
BEGIN
IF query.limit_time_periods IS NOT NULL THEN
time_col_type := get_time_field_type(query.namespace_name);
time_col_type := get_time_field_type(query.hypertable_name);
trange := get_time_periods_limit(epoch,
replica_id,
replica_id,
combine_predicates(default_predicates(query, epoch), additional_constraints),
(query.aggregate).group_time,
query.limit_time_periods);
additional_constraints := combine_predicates(
format('%1$I >= %2$s AND %1$I <=%3$s',
get_time_field(query.namespace_name),
_sysinternal.time_literal_sql(trange.start_time, time_col_type),
format('%1$I >= %2$s AND %1$I <=%3$s',
get_time_field(query.hypertable_name),
_sysinternal.time_literal_sql(trange.start_time, time_col_type),
_sysinternal.time_literal_sql(trange.end_time, time_col_type)
),
additional_constraints);
@ -513,6 +513,3 @@ BEGIN
RETURN grouped_sql;
END
$BODY$;

10
extension/sql/main/ioql_optimized_nonagg.sql
View File

@ -22,8 +22,8 @@ DECLARE
crn_row chunk_replica_node;
partition_row partition;
BEGIN
time_col_name := get_time_field(query.namespace_name);
time_col_type := get_time_field_type(query.namespace_name);
time_col_name := get_time_field(query.hypertable_name);
time_col_type := get_time_field_type(query.hypertable_name);
IF epoch.partitioning_field = (query.limit_by_field).field THEN
SELECT *
@ -247,7 +247,7 @@ BEGIN
string_agg(code_part, ' UNION ALL '),
(query.limit_by_field).count,
get_limit_clause(query.limit_rows),
get_time_field(query.namespace_name)
get_time_field(query.hypertable_name)
)
INTO STRICT code
FROM
@ -265,7 +265,7 @@ BEGIN
$$,
string_agg(code_part, ' UNION ALL '),
get_limit_clause(query.limit_rows),
get_time_field(query.namespace_name)
get_time_field(query.hypertable_name)
)
INTO STRICT code
FROM
@ -277,5 +277,3 @@ BEGIN
RETURN code;
END
$BODY$;

5
extension/sql/main/ioql_remote_calls.sql
View File

@ -19,7 +19,7 @@ BEGIN
SELECT hr.replica_id
INTO STRICT query_replica_id
FROM hypertable_replica hr
WHERE hr.hypertable_name = query.namespace_name
WHERE hr.hypertable_name = query.hypertable_name
ORDER BY random()
LIMIT 1;
@ -27,7 +27,7 @@ BEGIN
SELECT DISTINCT crn.database_name
FROM partition_replica pr
INNER JOIN chunk_replica_node crn ON (crn.partition_replica_id = pr.id)
WHERE pr.hypertable_name = query.namespace_name AND
WHERE pr.hypertable_name = query.hypertable_name AND
pr.replica_id = query_replica_id
)
INTO database_names;
@ -103,4 +103,3 @@ BEGIN
END
$BODY$
LANGUAGE plpgsql STABLE;

6
extension/sql/main/ioql_result_schema_agg.sql
View File

@ -28,11 +28,11 @@ SELECT CASE
WHEN (query.aggregate).group_field IS NOT NULL THEN
ARRAY [
format('%I %s', (query.aggregate).group_field,
get_field_type(query.namespace_name, (query.aggregate).group_field)),
'time '|| get_time_field_type(query.namespace_name) ] ||
get_field_type(query.hypertable_name, (query.aggregate).group_field)),
'time '|| get_time_field_type(query.hypertable_name) ] ||
field_array
ELSE
ARRAY ['time '|| get_time_field_type(query.namespace_name)] ||
ARRAY ['time '|| get_time_field_type(query.hypertable_name)] ||
field_array
END
FROM

8
extension/sql/main/ioql_result_schema_nonagg.sql
View File

@ -5,7 +5,7 @@ CREATE OR REPLACE FUNCTION get_result_field_array_nonagg(query ioql_query)
$BODY$
SELECT CASE
WHEN query.select_items IS NULL THEN
get_field_names(query.namespace_name)
get_field_names(query.hypertable_name)
ELSE
ARRAY(
SELECT *
@ -13,7 +13,7 @@ SELECT CASE
(
(
SELECT time_field AS field_name
FROM get_time_field(query.namespace_name) time_field
FROM get_time_field(query.hypertable_name) time_field
WHERE time_field NOT IN (
SELECT field AS field_name
FROM unnest(query.select_items)
@ -64,7 +64,7 @@ CREATE OR REPLACE FUNCTION get_result_field_def_array_nonagg(query ioql_query)
$BODY$
SELECT ARRAY(
SELECT format('%I %s', field, data_type)
FROM get_field_names_and_types(query.namespace_name,
FROM get_field_names_and_types(query.hypertable_name,
get_result_field_array_nonagg(query)) AS ft(field, data_type)
)
$BODY$;
@ -75,5 +75,3 @@ CREATE OR REPLACE FUNCTION get_result_column_def_list_nonagg(query ioql_query)
$BODY$
SELECT array_to_string(get_result_field_def_array_nonagg(query), ', ')
$BODY$;

8
extension/sql/main/ioql_sql_gen.sql
View File

@ -50,7 +50,7 @@ CREATE OR REPLACE FUNCTION get_time_predicate(time_col_name NAME, time_col_type
$BODY$
SELECT string_agg(clauses.val, ' AND ')
FROM (
VALUES (format('%I >= ', time_col_name) || NULLIF(_sysinternal.time_literal_sql(cond.from_time, time_col_type), 'NULL')),
VALUES (format('%I >= ', time_col_name) || NULLIF(_sysinternal.time_literal_sql(cond.from_time, time_col_type), 'NULL')),
(format('%I < ', time_col_name) || NULLIF(_sysinternal.time_literal_sql(cond.to_time, time_col_type), 'NULL'))
) AS clauses(val);
$BODY$;
@ -116,7 +116,7 @@ CREATE OR REPLACE FUNCTION default_predicates(query ioql_query, epoch partition_
RETURNS TEXT LANGUAGE SQL STABLE AS
$BODY$
SELECT combine_predicates(
get_time_predicate(get_time_field(query.namespace_name), get_time_field_type(query.namespace_name), query.time_condition),
get_time_predicate(get_time_field(query.hypertable_name), get_time_field_type(query.hypertable_name), query.time_condition),
get_field_predicate_clause(query.field_condition),
get_select_field_predicate(query.select_items),
get_partitioning_predicate(query, epoch)
@ -159,9 +159,9 @@ CREATE OR REPLACE FUNCTION get_orderby_clause_nonagg(query ioql_query)
$BODY$
SELECT CASE
WHEN query.limit_by_field IS NOT NULL THEN
format('ORDER BY %I DESC NULLS LAST, %s', get_time_field(query.namespace_name), (query.limit_by_field).field)
format('ORDER BY %I DESC NULLS LAST, %s', get_time_field(query.hypertable_name), (query.limit_by_field).field)
ELSE
format('ORDER BY %I DESC NULLS LAST', get_time_field(query.namespace_name))
format('ORDER BY %I DESC NULLS LAST', get_time_field(query.hypertable_name))
END;
$BODY$;

9
extension/sql/main/ioql_sqlgen_cluster_agg.sql
View File

@ -13,7 +13,7 @@ SELECT format(
get_finalize_aggregate_sql(query.select_items, query.aggregate),
get_partial_aggregate_column_def(query),
get_groupby_clause(query.aggregate),
query.namespace_name,
query.hypertable_name,
query,
epoch
)
@ -41,8 +41,8 @@ BEGIN
get_limit_clause(query.limit_rows),
(query.aggregate).group_time,
query.limit_time_periods,
_sysinternal.extract_time_sql('time', get_time_field_type(query.namespace_name)),
_sysinternal.extract_time_sql('without_limit.time', get_time_field_type(query.namespace_name))
_sysinternal.extract_time_sql('time', get_time_field_type(query.hypertable_name)),
_sysinternal.extract_time_sql('without_limit.time', get_time_field_type(query.hypertable_name))
);
ELSE
RETURN format(
@ -60,6 +60,3 @@ BEGIN
END;
$BODY$
SET constraint_exclusion = ON;

8
extension/sql/main/ioql_sqlgen_cluster_nonagg.sql
View File

@ -14,10 +14,10 @@ BEGIN
$$,
get_result_column_def_list_nonagg(query),
query,
query.namespace_name,
query.hypertable_name,
get_limit_clause(query.limit_rows),
epoch,
get_time_field(query.namespace_name)
get_time_field(query.hypertable_name)
);
END
$BODY$;
@ -49,7 +49,7 @@ BEGIN
ioql_query_nonagg_without_limit_sql(query, epoch),
get_limit_clause(query.limit_rows),
(query.limit_by_field).count,
get_time_field(query.namespace_name)
get_time_field(query.hypertable_name)
);
ELSE
RETURN format(
@ -64,7 +64,7 @@ BEGIN
get_result_column_list_nonagg(query),
ioql_query_nonagg_without_limit_sql(query, epoch),
get_limit_clause(query.limit_rows),
get_time_field(query.namespace_name)
get_time_field(query.hypertable_name)
);
END IF;
END;

4
extension/sql/main/kafka_offset_node_trigger.sql
View File

@ -12,7 +12,7 @@ CREATE OR REPLACE FUNCTION _sysinternal.on_create_node_insert_kafka_offset_node(
$BODY$
BEGIN
IF TG_OP <> 'INSERT' THEN
RAISE EXCEPTION 'Only inserts supported on namespace table'
RAISE EXCEPTION 'Only inserts supported on node table'
USING ERRCODE = 'IO101';
END IF;
@ -49,7 +49,7 @@ DECLARE
remote_node node;
BEGIN
IF TG_OP <> 'INSERT' THEN
RAISE EXCEPTION 'Only inserts supported on namespace table'
RAISE EXCEPTION 'Only inserts supported on kafka offset table'
USING ERRCODE = 'IO101';
END IF;

4
extension/sql/main/schema_info.sql
View File

@ -119,7 +119,7 @@ BEGIN
WHERE f.hypertable_name = get_field_names_and_types.hypertable_name AND
f.name = field_name
);
RAISE 'Missing field "%" in namespace "%"', missing_field, hypertable_name
RAISE 'Missing field "%" in hypertable "%"', missing_field, hypertable_name
USING ERRCODE = 'IO002';
END;
END IF;
@ -145,7 +145,7 @@ BEGIN
WHERE f.name = get_field_type.field_name AND f.hypertable_name = get_field_type.hypertable_name;
IF NOT FOUND THEN
RAISE 'Missing field "%" in namespace "%"', field_name, hypertable_name
RAISE 'Missing field "%" in hypertable "%"', field_name, hypertable_name
USING ERRCODE = 'IO002';
END IF;
RETURN data_type;

18
extension/sql/tests/regression/expected/ioql_query.out
View File

@ -1,6 +1,6 @@
\c Test1
SELECT *
FROM ioql_exec_query(new_ioql_query(namespace_name => 'testNs'));
FROM ioql_exec_query(new_ioql_query(hypertable_name => 'testNs'));
json
-----------------------------------------------------------------------------------------------------------------------
{"timeCustom":1257987600000000000,"device_id":"dev1","series_0":1.5,"series_1":1,"series_2":null,"series_bool":null}
@ -17,10 +17,10 @@ FROM ioql_exec_query(new_ioql_query(namespace_name => 'testNs'));
\set ON_ERROR_STOP 0
SELECT *
FROM ioql_exec_query(new_ioql_query(namespace_name => 'DoesNotExist'));
FROM ioql_exec_query(new_ioql_query(hypertable_name => 'DoesNotExist'));
\set ON_ERROR_STOP 1
SELECT *
FROM ioql_exec_query(new_ioql_query(namespace_name => 'testNs',
FROM ioql_exec_query(new_ioql_query(hypertable_name => 'testNs',
select_items => ARRAY [new_select_item('series_0', 'SUM')],
aggregate => new_aggregate((100 * 60 * 60 * 1e9) :: BIGINT)
));
@ -30,7 +30,7 @@ FROM ioql_exec_query(new_ioql_query(namespace_name => 'testNs',
(1 row)
SELECT *
FROM ioql_exec_query(new_ioql_query(namespace_name => 'testNs',
FROM ioql_exec_query(new_ioql_query(hypertable_name => 'testNs',
select_items => ARRAY [new_select_item('series_0', 'SUM')],
aggregate => new_aggregate((100 * 60 * 60 * 1e9) :: BIGINT),
limit_rows => 1
@ -41,7 +41,7 @@ FROM ioql_exec_query(new_ioql_query(namespace_name => 'testNs',
(1 row)
SELECT *
FROM ioql_exec_query(new_ioql_query(namespace_name => 'testNs',
FROM ioql_exec_query(new_ioql_query(hypertable_name => 'testNs',
select_items => ARRAY [new_select_item('series_0', 'SUM')],
aggregate => new_aggregate((100 * 60 * 60 * 1e9) :: BIGINT, 'series_1')
));
@ -55,7 +55,7 @@ FROM ioql_exec_query(new_ioql_query(namespace_name => 'testNs',
(5 rows)
SELECT *
FROM ioql_exec_query(new_ioql_query(namespace_name => 'testNs',
FROM ioql_exec_query(new_ioql_query(hypertable_name => 'testNs',
select_items => ARRAY [new_select_item('series_0', 'SUM')],
aggregate => new_aggregate((100 * 60 * 60 * 1e9) :: BIGINT, 'series_1'),
limit_rows => 1
@ -66,7 +66,7 @@ FROM ioql_exec_query(new_ioql_query(namespace_name => 'testNs',
(1 row)
SELECT *
FROM ioql_exec_query(new_ioql_query(namespace_name => 'testNs',
FROM ioql_exec_query(new_ioql_query(hypertable_name => 'testNs',
select_items => ARRAY [new_select_item('series_0', 'SUM')],
aggregate => new_aggregate((100 * 60 * 60 * 1e9) :: BIGINT, 'series_1'),
limit_time_periods => 1
@ -81,7 +81,7 @@ FROM ioql_exec_query(new_ioql_query(namespace_name => 'testNs',
(5 rows)
SELECT *
FROM ioql_exec_query(new_ioql_query(namespace_name => 'testNs',
FROM ioql_exec_query(new_ioql_query(hypertable_name => 'testNs',
select_items => ARRAY [new_select_item('series_0')],
limit_by_field => new_limit_by_field('device_id', 1)
));
@ -92,7 +92,7 @@ FROM ioql_exec_query(new_ioql_query(namespace_name => 'testNs',
(2 rows)
SELECT *
FROM ioql_exec_query(new_ioql_query(namespace_name => 'testNs',
FROM ioql_exec_query(new_ioql_query(hypertable_name => 'testNs',
select_items => ARRAY [new_select_item('series_0')],
limit_rows => 1
));

44
extension/sql/tests/regression/expected/timestamp.out
View File

@ -72,7 +72,7 @@ SELECT * FROM PUBLIC."testNs";
(5 rows)
SELECT *
FROM ioql_exec_query(new_ioql_query(namespace_name => 'testNs'));
FROM ioql_exec_query(new_ioql_query(hypertable_name => 'testNs'));
json
------------------------------------------------------------------------------------------------------------------------
{"timeCustom":"2009-11-12T01:00:00","device_id":"dev1","series_0":1.5,"series_1":1,"series_2":null,"series_bool":null}
@ -86,7 +86,7 @@ FROM ioql_exec_query(new_ioql_query(namespace_name => 'testNs'));
The next 2 queries will differ in output between UTC and EST since the mod is on the 100th hour UTC
SET timezone = 'UTC';
SELECT *
FROM ioql_exec_query(new_ioql_query(namespace_name => 'testNs',
FROM ioql_exec_query(new_ioql_query(hypertable_name => 'testNs',
select_items => ARRAY [new_select_item('series_0', 'SUM')],
aggregate => new_aggregate((100 * 60 * 60 * 1e6) :: BIGINT)
));
@ -97,7 +97,7 @@ FROM ioql_exec_query(new_ioql_query(namespace_name => 'testNs',
SET timezone = 'EST';
SELECT *
FROM ioql_exec_query(new_ioql_query(namespace_name => 'testNs',
FROM ioql_exec_query(new_ioql_query(hypertable_name => 'testNs',
select_items => ARRAY [new_select_item('series_0', 'SUM')],
aggregate => new_aggregate((100 * 60 * 60 * 1e6) :: BIGINT)
));
@ -110,7 +110,7 @@ FROM ioql_exec_query(new_ioql_query(namespace_name => 'testNs',
The rest of the queries will be the same in output between UTC and EST
SET timezone = 'UTC';
SELECT *
FROM ioql_exec_query(new_ioql_query(namespace_name => 'testNs',
FROM ioql_exec_query(new_ioql_query(hypertable_name => 'testNs',
select_items => ARRAY [new_select_item('series_0', 'SUM')],
aggregate => new_aggregate((1 * 60 * 60 * 1e6) :: BIGINT)
));
@ -122,7 +122,7 @@ FROM ioql_exec_query(new_ioql_query(namespace_name => 'testNs',
SET timezone = 'EST';
SELECT *
FROM ioql_exec_query(new_ioql_query(namespace_name => 'testNs',
FROM ioql_exec_query(new_ioql_query(hypertable_name => 'testNs',
select_items => ARRAY [new_select_item('series_0', 'SUM')],
aggregate => new_aggregate((1 * 60 * 60 * 1e6) :: BIGINT)
));
@ -134,7 +134,7 @@ FROM ioql_exec_query(new_ioql_query(namespace_name => 'testNs',
SET timezone = 'UTC';
SELECT *
FROM ioql_exec_query(new_ioql_query(namespace_name => 'testNs',
FROM ioql_exec_query(new_ioql_query(hypertable_name => 'testNs',
select_items => ARRAY [new_select_item('series_0', 'SUM')],
aggregate => new_aggregate((1 * 60 * 60 * 1e6) :: BIGINT)
));
@ -146,7 +146,7 @@ FROM ioql_exec_query(new_ioql_query(namespace_name => 'testNs',
SET timezone = 'EST';
SELECT *
FROM ioql_exec_query(new_ioql_query(namespace_name => 'testNs',
FROM ioql_exec_query(new_ioql_query(hypertable_name => 'testNs',
select_items => ARRAY [new_select_item('series_0', 'SUM')],
aggregate => new_aggregate((1 * 60 * 60 * 1e6) :: BIGINT)
));
@ -158,7 +158,7 @@ FROM ioql_exec_query(new_ioql_query(namespace_name => 'testNs',
SET timezone = 'UTC';
SELECT *
FROM ioql_exec_query(new_ioql_query(namespace_name => 'testNs',
FROM ioql_exec_query(new_ioql_query(hypertable_name => 'testNs',
time_condition=>new_time_condition(1257894000000000,1257987600000000) --microseconds
));
json
@ -170,7 +170,7 @@ FROM ioql_exec_query(new_ioql_query(namespace_name => 'testNs',
SET timezone = 'EST';
SELECT *
FROM ioql_exec_query(new_ioql_query(namespace_name => 'testNs',
FROM ioql_exec_query(new_ioql_query(hypertable_name => 'testNs',
time_condition=>new_time_condition(1257894000000000,1257987600000000) --microseconds
));
json
@ -182,19 +182,19 @@ FROM ioql_exec_query(new_ioql_query(namespace_name => 'testNs',
SET timezone = 'UTC';
SELECT *
FROM ioql_exec_query(new_ioql_query(namespace_name => 'testNs',
select_items => ARRAY [new_select_item('series_0', 'SUM')],
aggregate => new_aggregate((1 * 60 * 60 * 1e6) :: BIGINT),
limit_time_periods => 2
));
json
--------------------------------------------------
{"time":"2009-11-12T01:00:00","sum(series_0)":3}
(1 row)
SET timezone = 'EST';
SELECT *
FROM ioql_exec_query(new_ioql_query(namespace_name => 'testNs',
FROM ioql_exec_query(new_ioql_query(hypertable_name => 'testNs',
select_items => ARRAY [new_select_item('series_0', 'SUM')],
aggregate => new_aggregate((1 * 60 * 60 * 1e6) :: BIGINT),
limit_time_periods => 2
));
json
--------------------------------------------------
{"time":"2009-11-12T01:00:00","sum(series_0)":3}
(1 row)
SET timezone = 'EST';
SELECT *
FROM ioql_exec_query(new_ioql_query(hypertable_name => 'testNs',
select_items => ARRAY [new_select_item('series_0', 'SUM')],
aggregate => new_aggregate((1 * 60 * 60 * 1e6) :: BIGINT),
limit_time_periods => 2

18
extension/sql/tests/regression/ioql_query.sql
View File

@ -8,54 +8,54 @@
\c Test1
SELECT *
FROM ioql_exec_query(new_ioql_query(namespace_name => 'testNs'));
FROM ioql_exec_query(new_ioql_query(hypertable_name => 'testNs'));
\set ON_ERROR_STOP 0
SELECT *
FROM ioql_exec_query(new_ioql_query(namespace_name => 'DoesNotExist'));
FROM ioql_exec_query(new_ioql_query(hypertable_name => 'DoesNotExist'));
\set ON_ERROR_STOP 1
SELECT *
FROM ioql_exec_query(new_ioql_query(namespace_name => 'testNs',
FROM ioql_exec_query(new_ioql_query(hypertable_name => 'testNs',
select_items => ARRAY [new_select_item('series_0', 'SUM')],
aggregate => new_aggregate((100 * 60 * 60 * 1e9) :: BIGINT)
));
SELECT *
FROM ioql_exec_query(new_ioql_query(namespace_name => 'testNs',
FROM ioql_exec_query(new_ioql_query(hypertable_name => 'testNs',
select_items => ARRAY [new_select_item('series_0', 'SUM')],
aggregate => new_aggregate((100 * 60 * 60 * 1e9) :: BIGINT),
limit_rows => 1
));
SELECT *
FROM ioql_exec_query(new_ioql_query(namespace_name => 'testNs',
FROM ioql_exec_query(new_ioql_query(hypertable_name => 'testNs',
select_items => ARRAY [new_select_item('series_0', 'SUM')],
aggregate => new_aggregate((100 * 60 * 60 * 1e9) :: BIGINT, 'series_1')
));
SELECT *
FROM ioql_exec_query(new_ioql_query(namespace_name => 'testNs',
FROM ioql_exec_query(new_ioql_query(hypertable_name => 'testNs',
select_items => ARRAY [new_select_item('series_0', 'SUM')],
aggregate => new_aggregate((100 * 60 * 60 * 1e9) :: BIGINT, 'series_1'),
limit_rows => 1
));
SELECT *
FROM ioql_exec_query(new_ioql_query(namespace_name => 'testNs',
FROM ioql_exec_query(new_ioql_query(hypertable_name => 'testNs',
select_items => ARRAY [new_select_item('series_0', 'SUM')],
aggregate => new_aggregate((100 * 60 * 60 * 1e9) :: BIGINT, 'series_1'),
limit_time_periods => 1
));
SELECT *
FROM ioql_exec_query(new_ioql_query(namespace_name => 'testNs',
FROM ioql_exec_query(new_ioql_query(hypertable_name => 'testNs',
select_items => ARRAY [new_select_item('series_0')],
limit_by_field => new_limit_by_field('device_id', 1)
));
SELECT *
FROM ioql_exec_query(new_ioql_query(namespace_name => 'testNs',
FROM ioql_exec_query(new_ioql_query(hypertable_name => 'testNs',
select_items => ARRAY [new_select_item('series_0')],
limit_rows => 1
));

36
extension/sql/tests/regression/timestamp.sql
View File

@ -3,7 +3,7 @@
\o /dev/null
\ir include/create_clustered_db.sql
\o
\o
\set ECHO ALL
\c meta
SELECT add_cluster_user('postgres', NULL);
@ -46,18 +46,18 @@ SELECT * FROM PUBLIC."testNs";
SELECT *
FROM ioql_exec_query(new_ioql_query(namespace_name => 'testNs'));
FROM ioql_exec_query(new_ioql_query(hypertable_name => 'testNs'));
\echo 'The next 2 queries will differ in output between UTC and EST since the mod is on the 100th hour UTC'
SET timezone = 'UTC';
SELECT *
FROM ioql_exec_query(new_ioql_query(namespace_name => 'testNs',
FROM ioql_exec_query(new_ioql_query(hypertable_name => 'testNs',
select_items => ARRAY [new_select_item('series_0', 'SUM')],
aggregate => new_aggregate((100 * 60 * 60 * 1e6) :: BIGINT)
));
SET timezone = 'EST';
SELECT *
FROM ioql_exec_query(new_ioql_query(namespace_name => 'testNs',
FROM ioql_exec_query(new_ioql_query(hypertable_name => 'testNs',
select_items => ARRAY [new_select_item('series_0', 'SUM')],
aggregate => new_aggregate((100 * 60 * 60 * 1e6) :: BIGINT)
));
@ -66,13 +66,13 @@ FROM ioql_exec_query(new_ioql_query(namespace_name => 'testNs',
SET timezone = 'UTC';
SELECT *
FROM ioql_exec_query(new_ioql_query(namespace_name => 'testNs',
FROM ioql_exec_query(new_ioql_query(hypertable_name => 'testNs',
select_items => ARRAY [new_select_item('series_0', 'SUM')],
aggregate => new_aggregate((1 * 60 * 60 * 1e6) :: BIGINT)
));
SET timezone = 'EST';
SELECT *
FROM ioql_exec_query(new_ioql_query(namespace_name => 'testNs',
FROM ioql_exec_query(new_ioql_query(hypertable_name => 'testNs',
select_items => ARRAY [new_select_item('series_0', 'SUM')],
aggregate => new_aggregate((1 * 60 * 60 * 1e6) :: BIGINT)
));
@ -81,13 +81,13 @@ FROM ioql_exec_query(new_ioql_query(namespace_name => 'testNs',
SET timezone = 'UTC';
SELECT *
FROM ioql_exec_query(new_ioql_query(namespace_name => 'testNs',
FROM ioql_exec_query(new_ioql_query(hypertable_name => 'testNs',
select_items => ARRAY [new_select_item('series_0', 'SUM')],
aggregate => new_aggregate((1 * 60 * 60 * 1e6) :: BIGINT)
));
SET timezone = 'EST';
SELECT *
FROM ioql_exec_query(new_ioql_query(namespace_name => 'testNs',
FROM ioql_exec_query(new_ioql_query(hypertable_name => 'testNs',
select_items => ARRAY [new_select_item('series_0', 'SUM')],
aggregate => new_aggregate((1 * 60 * 60 * 1e6) :: BIGINT)
));
@ -95,26 +95,26 @@ FROM ioql_exec_query(new_ioql_query(namespace_name => 'testNs',
SET timezone = 'UTC';
SELECT *
FROM ioql_exec_query(new_ioql_query(namespace_name => 'testNs',
FROM ioql_exec_query(new_ioql_query(hypertable_name => 'testNs',
time_condition=>new_time_condition(1257894000000000,1257987600000000) --microseconds
));
SET timezone = 'EST';
SELECT *
FROM ioql_exec_query(new_ioql_query(namespace_name => 'testNs',
FROM ioql_exec_query(new_ioql_query(hypertable_name => 'testNs',
time_condition=>new_time_condition(1257894000000000,1257987600000000) --microseconds
));
SET timezone = 'UTC';
SELECT *
FROM ioql_exec_query(new_ioql_query(namespace_name => 'testNs',
select_items => ARRAY [new_select_item('series_0', 'SUM')],
aggregate => new_aggregate((1 * 60 * 60 * 1e6) :: BIGINT),
limit_time_periods => 2
));
SET timezone = 'EST';
SELECT *
FROM ioql_exec_query(new_ioql_query(namespace_name => 'testNs',
FROM ioql_exec_query(new_ioql_query(hypertable_name => 'testNs',
select_items => ARRAY [new_select_item('series_0', 'SUM')],
aggregate => new_aggregate((1 * 60 * 60 * 1e6) :: BIGINT),
limit_time_periods => 2
));
SET timezone = 'EST';
SELECT *
FROM ioql_exec_query(new_ioql_query(hypertable_name => 'testNs',
select_items => ARRAY [new_select_item('series_0', 'SUM')],
aggregate => new_aggregate((1 * 60 * 60 * 1e6) :: BIGINT),
limit_time_periods => 2

24
extension/sql/tests/unit/tests/ioql_empty_test.sql
View File

@ -6,34 +6,34 @@ DECLARE
message test_result;
success boolean;
BEGIN
PERFORM test_utils.test_query(new_ioql_query(namespace_name => 'emptyNs',
PERFORM test_utils.test_query(new_ioql_query(hypertable_name => 'emptyNs',
select_items => ARRAY[new_select_item('nUm_1'::text,
NULL::aggregate_function_type)]), 'test_outputs', 'empty_result');
PERFORM test_utils.test_query(new_ioql_query(namespace_name => 'emptyNs',
PERFORM test_utils.test_query(new_ioql_query(hypertable_name => 'emptyNs',
select_items => ARRAY[new_select_item('nUm_1'::text, 'SUM'::aggregate_function_type)],
aggregate => new_aggregate(2592000000000000, NULL)), 'test_outputs', 'empty_result');
PERFORM test_utils.test_query(new_ioql_query(namespace_name => 'emptyNs',
PERFORM test_utils.test_query(new_ioql_query(hypertable_name => 'emptyNs',
select_items => ARRAY[new_select_item('nUm_1'::text, 'AVG'::aggregate_function_type)],
aggregate => new_aggregate(2592000000000000, NULL)), 'test_outputs', 'empty_result');
PERFORM test_utils.test_query(new_ioql_query(namespace_name => 'emptyNs',
PERFORM test_utils.test_query(new_ioql_query(hypertable_name => 'emptyNs',
select_items => ARRAY[new_select_item('nUm_1'::text, 'MAX'::aggregate_function_type)],
aggregate => new_aggregate(2592000000000000, NULL)), 'test_outputs', 'empty_result');
PERFORM test_utils.test_query(new_ioql_query(namespace_name => 'emptyNs',
PERFORM test_utils.test_query(new_ioql_query(hypertable_name => 'emptyNs',
select_items => ARRAY[new_select_item('nUm_1'::text, 'MIN'::aggregate_function_type)],
aggregate => new_aggregate(2592000000000000, NULL)), 'test_outputs', 'empty_result');
PERFORM test_utils.test_query(new_ioql_query(namespace_name => 'emptyNs',
PERFORM test_utils.test_query(new_ioql_query(hypertable_name => 'emptyNs',
select_items => ARRAY[new_select_item('nUm_1'::text, 'COUNT'::aggregate_function_type)],
aggregate => new_aggregate(2592000000000000, NULL)), 'test_outputs', 'empty_result');
PERFORM test_utils.test_query(new_ioql_query(namespace_name => 'emptyNs',
PERFORM test_utils.test_query(new_ioql_query(hypertable_name => 'emptyNs',
select_items => ARRAY[new_select_item('nUm_1'::text, 'SUM'::aggregate_function_type)],
aggregate => new_aggregate(2592000000000000, 'device_id')), 'test_outputs', 'empty_result');
aggregate => new_aggregate(2592000000000000, 'device_id')), 'test_outputs', 'empty_result');
SELECT assert.ok('End of test.') INTO message;
RETURN message;

12
extension/sql/tests/unit/tests/ioql_nonexisting_test.sql
View File

@ -6,9 +6,9 @@ DECLARE
message test_result;
success boolean;
BEGIN
BEGIN
PERFORM test_utils.test_query(new_ioql_query(namespace_name=>'UNKNOWN_HT'), 'test_outputs', 'empty_result');
BEGIN
PERFORM test_utils.test_query(new_ioql_query(hypertable_name=>'UNKNOWN_HT'), 'test_outputs', 'empty_result');
EXCEPTION WHEN SQLSTATE 'IO001' THEN
SELECT assert.ok('End of test.') INTO message;
RETURN message;
@ -29,9 +29,9 @@ DECLARE
message test_result;
success boolean;
BEGIN
BEGIN
PERFORM test_utils.test_query(new_ioql_query(namespace_name=>'33_testNs',
BEGIN
PERFORM test_utils.test_query(new_ioql_query(hypertable_name=>'33_testNs',
select_items=>ARRAY[new_select_item('field_does_not_exist'::text,NULL::aggregate_function_type)]), 'test_outputs', 'empty_result');
EXCEPTION WHEN SQLSTATE 'IO002' THEN
SELECT assert.ok('End of test.') INTO message;

148
extension/sql/tests/unit/tests/ioql_queries_test.sql
View File

@ -6,297 +6,297 @@ DECLARE
message test_result;
success boolean;
BEGIN
PERFORM test_utils.test_query(new_ioql_query(namespace_name=>'33_testNs'), 'test_outputs', 'output_0');
PERFORM test_utils.test_query(new_ioql_query(namespace_name=>'33_testNs'), 'test_outputs', 'output_0');
PERFORM test_utils.test_query(new_ioql_query(hypertable_name=>'33_testNs'), 'test_outputs', 'output_0');
PERFORM test_utils.test_query(new_ioql_query(hypertable_name=>'33_testNs'), 'test_outputs', 'output_0');
PERFORM test_utils.test_query(new_ioql_query(namespace_name=>'33_testNs',
PERFORM test_utils.test_query(new_ioql_query(hypertable_name=>'33_testNs',
select_items=>ARRAY[new_select_item('nUm_1'::text,NULL::aggregate_function_type)]), 'test_outputs', 'output_1');
PERFORM test_utils.test_query(new_ioql_query(namespace_name=>'33_testNs',
PERFORM test_utils.test_query(new_ioql_query(hypertable_name=>'33_testNs',
select_items=>ARRAY[new_select_item('bool_1'::text,NULL::aggregate_function_type)]), 'test_outputs', 'output_2');
PERFORM test_utils.test_query(new_ioql_query(namespace_name=>'33_testNs',
PERFORM test_utils.test_query(new_ioql_query(hypertable_name=>'33_testNs',
select_items=>ARRAY[new_select_item('string_1'::text,NULL::aggregate_function_type)]), 'test_outputs', 'output_3');
PERFORM test_utils.test_query(new_ioql_query(namespace_name=>'33_testNs',
PERFORM test_utils.test_query(new_ioql_query(hypertable_name=>'33_testNs',
select_items=>ARRAY[new_select_item('field_only_dev2'::text,NULL::aggregate_function_type)]), 'test_outputs', 'output_4');
PERFORM test_utils.test_query(new_ioql_query(namespace_name=>'33_testNs',
PERFORM test_utils.test_query(new_ioql_query(hypertable_name=>'33_testNs',
select_items=>ARRAY[new_select_item('field_only_ref2'::text,NULL::aggregate_function_type)]), 'test_outputs', 'output_5');
PERFORM test_utils.test_query(new_ioql_query(namespace_name=>'33_testNs',limit_rows=>2), 'test_outputs', 'output_7');
PERFORM test_utils.test_query(new_ioql_query(hypertable_name=>'33_testNs',limit_rows=>2), 'test_outputs', 'output_7');
PERFORM test_utils.test_query(new_ioql_query(namespace_name=>'33_testNs',
PERFORM test_utils.test_query(new_ioql_query(hypertable_name=>'33_testNs',
limit_by_field=>new_limit_by_field('device_id',1)), 'test_outputs', 'output_8');
PERFORM test_utils.test_query(new_ioql_query(namespace_name=>'33_testNs',
PERFORM test_utils.test_query(new_ioql_query(hypertable_name=>'33_testNs',
limit_by_field=>new_limit_by_field('string_1',2)), 'test_outputs', 'output_9');
PERFORM test_utils.test_query(new_ioql_query(namespace_name=>'33_testNs',
PERFORM test_utils.test_query(new_ioql_query(hypertable_name=>'33_testNs',
limit_by_field=>new_limit_by_field('string_2',1)), 'test_outputs', 'output_10');
PERFORM test_utils.test_query(new_ioql_query(namespace_name=>'33_testNs',
PERFORM test_utils.test_query(new_ioql_query(hypertable_name=>'33_testNs',
select_items=>ARRAY[new_select_item('nUm_1'::text,NULL::aggregate_function_type)],
limit_by_field=>new_limit_by_field('string_2',1)), 'test_outputs', 'output_11');
/*
Should throw error as field_only_dev2 is not distinct, bug filed
PERFORM test_utils.test_query(new_ioql_query(namespace_name=>'33_testNs',
PERFORM test_utils.test_query(new_ioql_query(hypertable_name=>'33_testNs',
limit_by_field=>new_limit_by_field('field_only_dev2',1)), 'test_outputs', 'output_12');
*/
PERFORM test_utils.test_query(new_ioql_query(namespace_name=>'33_testNs',
PERFORM test_utils.test_query(new_ioql_query(hypertable_name=>'33_testNs',
time_condition=>new_time_condition(NULL,910738800000000000),
limit_by_field=>new_limit_by_field('device_id',1)), 'test_outputs', 'output_13');
PERFORM test_utils.test_query(new_ioql_query(namespace_name=>'33_testNs',
PERFORM test_utils.test_query(new_ioql_query(hypertable_name=>'33_testNs',
select_items=>ARRAY[new_select_item('nUm_1'::text,NULL::aggregate_function_type)],
time_condition=>new_time_condition(NULL,910738800000000000),
limit_by_field=>new_limit_by_field('device_id',1)), 'test_outputs', 'output_14');
PERFORM test_utils.test_query(new_ioql_query(namespace_name=>'33_testNs',
PERFORM test_utils.test_query(new_ioql_query(hypertable_name=>'33_testNs',
time_condition=>new_time_condition(NULL,1257987600000000000)), 'test_outputs', 'output_15');
PERFORM test_utils.test_query(new_ioql_query(namespace_name=>'33_testNs',
PERFORM test_utils.test_query(new_ioql_query(hypertable_name=>'33_testNs',
time_condition=>new_time_condition(NULL,1257987601000000000)), 'test_outputs', 'output_16');
PERFORM test_utils.test_query(new_ioql_query(namespace_name=>'33_testNs',
PERFORM test_utils.test_query(new_ioql_query(hypertable_name=>'33_testNs',
time_condition=>new_time_condition(1257894000000000000,NULL)), 'test_outputs', 'output_17');
PERFORM test_utils.test_query(new_ioql_query(namespace_name=>'33_testNs',
PERFORM test_utils.test_query(new_ioql_query(hypertable_name=>'33_testNs',
time_condition=>new_time_condition(1257987600000000000,NULL)), 'test_outputs', 'output_18');
PERFORM test_utils.test_query(new_ioql_query(namespace_name=>'33_testNs',
PERFORM test_utils.test_query(new_ioql_query(hypertable_name=>'33_testNs',
time_condition=>new_time_condition(1257894000000000000,1257987600000000000)),
'test_outputs', 'output_19');
PERFORM test_utils.test_query(new_ioql_query(namespace_name=>'33_testNs',
PERFORM test_utils.test_query(new_ioql_query(hypertable_name=>'33_testNs',
time_condition=>new_time_condition(1257894000000000000,1257987601000000000)),
'test_outputs', 'output_20');
PERFORM test_utils.test_query(new_ioql_query(namespace_name=>'33_testNs',
PERFORM test_utils.test_query(new_ioql_query(hypertable_name=>'33_testNs',
field_condition=>new_field_condition('AND',ARRAY[new_field_predicate('nUm_1','=',1.5::text)])),
'test_outputs', 'output_21');
PERFORM test_utils.test_query(new_ioql_query(namespace_name=>'33_testNs',
PERFORM test_utils.test_query(new_ioql_query(hypertable_name=>'33_testNs',
field_condition=>new_field_condition('AND',ARRAY[new_field_predicate('nUm_1','=',1.6::text)])),
'test_outputs', 'output_22');
PERFORM test_utils.test_query(new_ioql_query(namespace_name=>'33_testNs',
PERFORM test_utils.test_query(new_ioql_query(hypertable_name=>'33_testNs',
field_condition=>new_field_condition('AND',ARRAY[new_field_predicate('nUm_1','!=',1.6::text)])),
'test_outputs', 'output_23');
PERFORM test_utils.test_query(new_ioql_query(namespace_name=>'33_testNs',
PERFORM test_utils.test_query(new_ioql_query(hypertable_name=>'33_testNs',
field_condition=>new_field_condition('AND',ARRAY[new_field_predicate('nUm_1','!=',1.5::text)])),
'test_outputs', 'output_24');
PERFORM test_utils.test_query(new_ioql_query(namespace_name=>'33_testNs',
PERFORM test_utils.test_query(new_ioql_query(hypertable_name=>'33_testNs',
field_condition=>new_field_condition('AND',ARRAY[new_field_predicate('nUm_1','>',1.4::text)])),
'test_outputs', 'output_25');
PERFORM test_utils.test_query(new_ioql_query(namespace_name=>'33_testNs',
PERFORM test_utils.test_query(new_ioql_query(hypertable_name=>'33_testNs',
field_condition=>new_field_condition('AND',ARRAY[new_field_predicate('nUm_1','>',1.5::text)])),
'test_outputs', 'output_26');
PERFORM test_utils.test_query(new_ioql_query(namespace_name=>'33_testNs',
PERFORM test_utils.test_query(new_ioql_query(hypertable_name=>'33_testNs',
field_condition=>new_field_condition('AND',ARRAY[new_field_predicate('nUm_1','>=',1.5::text)])),
'test_outputs', 'output_27');
PERFORM test_utils.test_query(new_ioql_query(namespace_name=>'33_testNs',
PERFORM test_utils.test_query(new_ioql_query(hypertable_name=>'33_testNs',
field_condition=>new_field_condition('AND',ARRAY[new_field_predicate('nUm_1','>=',1.51::text)])),
'test_outputs', 'output_28');
PERFORM test_utils.test_query(new_ioql_query(namespace_name=>'33_testNs',
PERFORM test_utils.test_query(new_ioql_query(hypertable_name=>'33_testNs',
field_condition=>new_field_condition('AND',ARRAY[new_field_predicate('nUm_1','<',1.6::text)])),
'test_outputs', 'output_29');
PERFORM test_utils.test_query(new_ioql_query(namespace_name=>'33_testNs',
PERFORM test_utils.test_query(new_ioql_query(hypertable_name=>'33_testNs',
field_condition=>new_field_condition('AND',ARRAY[new_field_predicate('nUm_1','<',1.5::text)])),
'test_outputs', 'output_30');
PERFORM test_utils.test_query(new_ioql_query(namespace_name=>'33_testNs',
PERFORM test_utils.test_query(new_ioql_query(hypertable_name=>'33_testNs',
field_condition=>new_field_condition('AND',ARRAY[new_field_predicate('nUm_1','<=',1.5::text)])),
'test_outputs', 'output_31');
PERFORM test_utils.test_query(new_ioql_query(namespace_name=>'33_testNs',
PERFORM test_utils.test_query(new_ioql_query(hypertable_name=>'33_testNs',
field_condition=>new_field_condition('AND',ARRAY[new_field_predicate('nUm_1','<=',1.49::text)])),
'test_outputs', 'output_32');
PERFORM test_utils.test_query(new_ioql_query(namespace_name=>'33_testNs',
PERFORM test_utils.test_query(new_ioql_query(hypertable_name=>'33_testNs',
field_condition=>new_field_condition('AND',ARRAY[new_field_predicate('device_id','=','dev1'::text)])),
'test_outputs', 'output_33');
PERFORM test_utils.test_query(new_ioql_query(namespace_name=>'33_testNs',
PERFORM test_utils.test_query(new_ioql_query(hypertable_name=>'33_testNs',
field_condition=>new_field_condition('AND',ARRAY[new_field_predicate('device_id','=','dev2'::text)])),
'test_outputs', 'output_34');
PERFORM test_utils.test_query(new_ioql_query(namespace_name=>'33_testNs',
PERFORM test_utils.test_query(new_ioql_query(hypertable_name=>'33_testNs',
field_condition=>new_field_condition('AND',ARRAY[new_field_predicate('device_id','=','dev3'::text)])),
'test_outputs', 'output_35');
PERFORM test_utils.test_query(new_ioql_query(namespace_name=>'33_testNs',
PERFORM test_utils.test_query(new_ioql_query(hypertable_name=>'33_testNs',
field_condition=>new_field_condition('AND',ARRAY[new_field_predicate('device_id','!=','dev2'::text)])),
'test_outputs', 'output_36');
PERFORM test_utils.test_query(new_ioql_query(namespace_name=>'33_testNs',
PERFORM test_utils.test_query(new_ioql_query(hypertable_name=>'33_testNs',
field_condition=>new_field_condition('AND',ARRAY[new_field_predicate('nUm_1','=',1.5::text),
new_field_predicate('num_2','=',0.0::text)])), 'test_outputs', 'output_37');
PERFORM test_utils.test_query(new_ioql_query(namespace_name=>'33_testNs',
PERFORM test_utils.test_query(new_ioql_query(hypertable_name=>'33_testNs',
field_condition=>new_field_condition('AND',ARRAY[new_field_predicate('nUm_1','=',1.5::text),
new_field_predicate('num_2','=',2.0::text)])), 'test_outputs', 'output_38');
PERFORM test_utils.test_query(new_ioql_query(namespace_name=>'33_testNs',
PERFORM test_utils.test_query(new_ioql_query(hypertable_name=>'33_testNs',
field_condition=>new_field_condition('AND',ARRAY[new_field_predicate('num_2','=',1.0::text),
new_field_predicate('num_2','=',2.0::text)])), 'test_outputs', 'output_39');
PERFORM test_utils.test_query(new_ioql_query(namespace_name=>'33_testNs',
PERFORM test_utils.test_query(new_ioql_query(hypertable_name=>'33_testNs',
field_condition=>new_field_condition('OR',ARRAY[new_field_predicate('nUm_1','=',1.5::text),
new_field_predicate('num_2','=',0.0::text)])), 'test_outputs', 'output_40');
PERFORM test_utils.test_query(new_ioql_query(namespace_name=>'33_testNs',
PERFORM test_utils.test_query(new_ioql_query(hypertable_name=>'33_testNs',
field_condition=>new_field_condition('OR',ARRAY[new_field_predicate('nUm_1','=',1.5::text),
new_field_predicate('num_2','=',2.0::text)])), 'test_outputs', 'output_41');
PERFORM test_utils.test_query(new_ioql_query(namespace_name=>'33_testNs',
PERFORM test_utils.test_query(new_ioql_query(hypertable_name=>'33_testNs',
field_condition=>new_field_condition('OR',ARRAY[new_field_predicate('num_2','=',1.0::text),
new_field_predicate('num_2','=',2.0::text)])), 'test_outputs', 'output_42');
PERFORM test_utils.test_query(new_ioql_query(namespace_name=>'33_testNs',
PERFORM test_utils.test_query(new_ioql_query(hypertable_name=>'33_testNs',
select_items=>ARRAY[new_select_item('nUm_1'::text,'SUM'::aggregate_function_type)],
aggregate=>new_aggregate(2592000000000000,NULL)), 'test_outputs', 'output_43');
PERFORM test_utils.test_query(new_ioql_query(namespace_name=>'33_testNs',
PERFORM test_utils.test_query(new_ioql_query(hypertable_name=>'33_testNs',
select_items=>ARRAY[new_select_item('nUm_1'::text,'SUM'::aggregate_function_type)],
aggregate=>new_aggregate(3600000000000,NULL)), 'test_outputs', 'output_44');
PERFORM test_utils.test_query(new_ioql_query(namespace_name=>'33_testNs',
PERFORM test_utils.test_query(new_ioql_query(hypertable_name=>'33_testNs',
select_items=>ARRAY[new_select_item('nUm_1'::text,'MAX'::aggregate_function_type)],
aggregate=>new_aggregate(2592000000000000,NULL)), 'test_outputs', 'output_45');
PERFORM test_utils.test_query(new_ioql_query(namespace_name=>'33_testNs',
PERFORM test_utils.test_query(new_ioql_query(hypertable_name=>'33_testNs',
select_items=>ARRAY[new_select_item('nUm_1'::text,'MAX'::aggregate_function_type)],
aggregate=>new_aggregate(3600000000000,NULL)), 'test_outputs', 'output_46');
PERFORM test_utils.test_query(new_ioql_query(namespace_name=>'33_testNs',
PERFORM test_utils.test_query(new_ioql_query(hypertable_name=>'33_testNs',
select_items=>ARRAY[new_select_item('nUm_1'::text,'MIN'::aggregate_function_type)],
aggregate=>new_aggregate(2592000000000000,NULL)), 'test_outputs', 'output_47');
PERFORM test_utils.test_query(new_ioql_query(namespace_name=>'33_testNs',
PERFORM test_utils.test_query(new_ioql_query(hypertable_name=>'33_testNs',
select_items=>ARRAY[new_select_item('nUm_1'::text,'MIN'::aggregate_function_type)],
aggregate=>new_aggregate(3600000000000,NULL)), 'test_outputs', 'output_48');
PERFORM test_utils.test_query(new_ioql_query(namespace_name=>'33_testNs',
PERFORM test_utils.test_query(new_ioql_query(hypertable_name=>'33_testNs',
select_items=>ARRAY[new_select_item('nUm_1'::text,'AVG'::aggregate_function_type)],
aggregate=>new_aggregate(2592000000000000,NULL)), 'test_outputs', 'output_49');
PERFORM test_utils.test_query(new_ioql_query(namespace_name=>'33_testNs',
PERFORM test_utils.test_query(new_ioql_query(hypertable_name=>'33_testNs',
select_items=>ARRAY[new_select_item('nUm_1'::text,'AVG'::aggregate_function_type)],
aggregate=>new_aggregate(3600000000000,NULL)), 'test_outputs', 'output_50');
PERFORM test_utils.test_query(new_ioql_query(namespace_name=>'33_testNs',
PERFORM test_utils.test_query(new_ioql_query(hypertable_name=>'33_testNs',
select_items=>ARRAY[new_select_item('nUm_1'::text,'COUNT'::aggregate_function_type)],
aggregate=>new_aggregate(2592000000000000,NULL)), 'test_outputs', 'output_51');
PERFORM test_utils.test_query(new_ioql_query(namespace_name=>'33_testNs',
PERFORM test_utils.test_query(new_ioql_query(hypertable_name=>'33_testNs',
select_items=>ARRAY[new_select_item('nUm_1'::text,'COUNT'::aggregate_function_type)],
aggregate=>new_aggregate(3600000000000,NULL)), 'test_outputs', 'output_52');
PERFORM test_utils.test_query(new_ioql_query(namespace_name=>'33_testNs',
PERFORM test_utils.test_query(new_ioql_query(hypertable_name=>'33_testNs',
select_items=>ARRAY[new_select_item('nUm_1'::text,'COUNT'::aggregate_function_type)],
aggregate=>new_aggregate(2592000000000000,NULL),
field_condition=>new_field_condition('AND',ARRAY[new_field_predicate('device_id','=','dev1'::text)])),
'test_outputs', 'output_53');
PERFORM test_utils.test_query(new_ioql_query(namespace_name=>'33_testNs',
PERFORM test_utils.test_query(new_ioql_query(hypertable_name=>'33_testNs',
select_items=>ARRAY[new_select_item('nUm_1'::text,'COUNT'::aggregate_function_type)],
aggregate=>new_aggregate(2592000000000000,NULL),
field_condition=>new_field_condition('AND',ARRAY[new_field_predicate('device_id','=','dev2'::text)])),
'test_outputs', 'output_54');
PERFORM test_utils.test_query(new_ioql_query(namespace_name=>'33_testNs',
PERFORM test_utils.test_query(new_ioql_query(hypertable_name=>'33_testNs',
select_items=>ARRAY[new_select_item('nUm_1'::text,'COUNT'::aggregate_function_type)],
aggregate=>new_aggregate(2592000000000000,NULL),
field_condition=>new_field_condition('AND',ARRAY[new_field_predicate('device_id','=','dev3'::text)])),
'test_outputs', 'output_55');
PERFORM test_utils.test_query(new_ioql_query(namespace_name=>'33_testNs',
PERFORM test_utils.test_query(new_ioql_query(hypertable_name=>'33_testNs',
select_items=>ARRAY[new_select_item('nUm_1'::text,'COUNT'::aggregate_function_type)],
aggregate=>new_aggregate(2592000000000000,NULL),
field_condition=>new_field_condition('AND',ARRAY[new_field_predicate('device_id','!=','dev2'::text)])),
'test_outputs', 'output_56');
PERFORM test_utils.test_query(new_ioql_query(namespace_name=>'33_testNs',
PERFORM test_utils.test_query(new_ioql_query(hypertable_name=>'33_testNs',
select_items=>ARRAY[new_select_item('nUm_1'::text,'MAX'::aggregate_function_type)],
aggregate=>new_aggregate(2592000000000000,NULL),
time_condition=>new_time_condition(1257894000000000000,1257987600000000000),
field_condition=>new_field_condition('AND',ARRAY[new_field_predicate('device_id','=','dev1'::text)]),
limit_rows=>100), 'test_outputs', 'output_57');
PERFORM test_utils.test_query(new_ioql_query(namespace_name=>'33_testNs',
PERFORM test_utils.test_query(new_ioql_query(hypertable_name=>'33_testNs',
select_items=>ARRAY[new_select_item('nUm_1'::text,'SUM'::aggregate_function_type)],
aggregate=>new_aggregate(3600000000000,NULL),limit_time_periods=>2), 'test_outputs', 'output_58');
PERFORM test_utils.test_query(new_ioql_query(namespace_name=>'33_testNs',
PERFORM test_utils.test_query(new_ioql_query(hypertable_name=>'33_testNs',
select_items=>ARRAY[new_select_item('nUm_1'::text,'SUM'::aggregate_function_type)],
aggregate=>new_aggregate(3600000000000,NULL),limit_time_periods=>200), 'test_outputs', 'output_59');
PERFORM test_utils.test_query(new_ioql_query(namespace_name=>'33_testNs',
PERFORM test_utils.test_query(new_ioql_query(hypertable_name=>'33_testNs',
select_items=>ARRAY[new_select_item('nUm_1'::text,'SUM'::aggregate_function_type)],
aggregate=>new_aggregate(3600000000000,NULL),limit_rows=>1), 'test_outputs', 'output_60');
PERFORM test_utils.test_query(new_ioql_query(namespace_name=>'33_testNs',
PERFORM test_utils.test_query(new_ioql_query(hypertable_name=>'33_testNs',
select_items=>ARRAY[new_select_item('nUm_1'::text,'SUM'::aggregate_function_type)],
aggregate=>new_aggregate(3600000000000,NULL),limit_rows=>200), 'test_outputs', 'output_61');
PERFORM test_utils.test_query(new_ioql_query(namespace_name=>'33_testNs',
PERFORM test_utils.test_query(new_ioql_query(hypertable_name=>'33_testNs',
select_items=>ARRAY[new_select_item('nUm_1'::text,'SUM'::aggregate_function_type)],
aggregate=>new_aggregate(3600000000000,NULL),limit_rows=>200,limit_time_periods=>2),
'test_outputs', 'output_62');
PERFORM test_utils.test_query(new_ioql_query(namespace_name=>'33_testNs',
PERFORM test_utils.test_query(new_ioql_query(hypertable_name=>'33_testNs',
select_items=>ARRAY[new_select_item('nUm_1'::text,'SUM'::aggregate_function_type)],
aggregate=>new_aggregate(3600000000000,NULL),limit_rows=>200,limit_time_periods=>200),
'test_outputs', 'output_63');
PERFORM test_utils.test_query(new_ioql_query(namespace_name=>'33_testNs',
PERFORM test_utils.test_query(new_ioql_query(hypertable_name=>'33_testNs',
select_items=>ARRAY[new_select_item('field_only_dev2'::text,'SUM'::aggregate_function_type)],
aggregate=>new_aggregate(3600000000000,NULL),limit_time_periods=>1), 'test_outputs', 'output_64');
PERFORM test_utils.test_query(new_ioql_query(namespace_name=>'33_testNs',
PERFORM test_utils.test_query(new_ioql_query(hypertable_name=>'33_testNs',
select_items=>ARRAY[new_select_item('nUm_1'::text,'COUNT'::aggregate_function_type)],
aggregate=>new_aggregate(3600000000000,'num_2')), 'test_outputs', 'output_65');
PERFORM test_utils.test_query(new_ioql_query(namespace_name=>'33_testNs',
PERFORM test_utils.test_query(new_ioql_query(hypertable_name=>'33_testNs',
select_items=>ARRAY[new_select_item('nUm_1'::text,'COUNT'::aggregate_function_type)],
aggregate=>new_aggregate(3600000000000,'string_2')), 'test_outputs', 'output_66');
PERFORM test_utils.test_query(new_ioql_query(namespace_name=>'33_testNs',
PERFORM test_utils.test_query(new_ioql_query(hypertable_name=>'33_testNs',
select_items=>ARRAY[new_select_item('nUm_1'::text,'COUNT'::aggregate_function_type)],
aggregate=>new_aggregate(3600000000000,'num_2'),limit_time_periods=>1), 'test_outputs', 'output_67');
PERFORM test_utils.test_query(new_ioql_query(namespace_name=>'33_testNs',
PERFORM test_utils.test_query(new_ioql_query(hypertable_name=>'33_testNs',
select_items=>ARRAY[new_select_item('nUm_1'::text,'COUNT'::aggregate_function_type)],
aggregate=>new_aggregate(3600000000000,'string_2'),limit_time_periods=>1), 'test_outputs', 'output_68');
PERFORM test_utils.test_query(new_ioql_query(namespace_name=>'33_testNs',
PERFORM test_utils.test_query(new_ioql_query(hypertable_name=>'33_testNs',
select_items=>ARRAY[new_select_item('nUm_1'::text,'COUNT'::aggregate_function_type)],
aggregate=>new_aggregate(2592000000000000,'num_2')), 'test_outputs', 'output_69');
PERFORM test_utils.test_query(new_ioql_query(namespace_name=>'33_testNs',
PERFORM test_utils.test_query(new_ioql_query(hypertable_name=>'33_testNs',
select_items=>ARRAY[new_select_item('nUm_1'::text,'COUNT'::aggregate_function_type)],
aggregate=>new_aggregate(2592000000000000,'string_2')), 'test_outputs', 'output_70');
PERFORM test_utils.test_query(new_ioql_query(namespace_name=>'33_testNs',
PERFORM test_utils.test_query(new_ioql_query(hypertable_name=>'33_testNs',
select_items=>ARRAY[new_select_item('nUm_1'::text,'COUNT'::aggregate_function_type)],
aggregate=>new_aggregate(2592000000000000,'field_only_dev2')), 'test_outputs', 'output_71');
PERFORM test_utils.test_query(new_ioql_query(namespace_name=>'33_testNs',
PERFORM test_utils.test_query(new_ioql_query(hypertable_name=>'33_testNs',
select_items=>ARRAY[new_select_item('nUm_1'::text,'COUNT'::aggregate_function_type)],
aggregate=>new_aggregate(3600000000000,'field_only_dev2'),limit_time_periods=>1),
'test_outputs', 'output_72');
PERFORM test_utils.test_query(new_ioql_query(namespace_name=>'33_testNs',
PERFORM test_utils.test_query(new_ioql_query(hypertable_name=>'33_testNs',
select_items=>ARRAY[new_select_item('device_id'::text,'COUNT'::aggregate_function_type)],
aggregate=>new_aggregate(3600000000000,'device_id'),limit_rows=>1), 'test_outputs', 'output_73');

4
extension/sql/tests/unit/utils/generate_expected_csv.sh
View File

@ -15,7 +15,7 @@ QUERY_DB=${QUERY_DB:-Test1}
if [ "$#" -ne 2 ] ; then
echo "usage: $0 query outputfile"
echo "ex: $0 \"new_ioql_query(namespace_name => '33_testNs')\" result.csv "
echo "ex: $0 \"new_ioql_query(hypertable_name => '33_testNs')\" result.csv "
echo "NOTE ! This script will not populate the db. You have to make sure the right data is imported before the query"
exit 1
fi
@ -57,4 +57,4 @@ tail -n +4 | sed "s/|//;s/|/;/;s/ */ /g;s/ ; /;/g" | tr -d '\n' | sed "s/.$//;s
cat $TMPFILE >> $OUTPUTFILE
rm $TMPFILE
cd $PWD
cd $PWD