mirror of https://github.com/citusdata/citus.git
1441 lines
53 KiB
Plaintext
1441 lines
53 KiB
Plaintext
--
|
|
-- MULTI_SCHEMA_SUPPORT
|
|
--
|
|
ALTER SEQUENCE pg_catalog.pg_dist_shardid_seq RESTART 1190000;
|
|
-- create schema to test schema support
|
|
CREATE SCHEMA test_schema_support;
|
|
-- test master_append_table_to_shard with schema
|
|
-- create local table to append
|
|
CREATE TABLE public.nation_local(
|
|
n_nationkey integer not null,
|
|
n_name char(25) not null,
|
|
n_regionkey integer not null,
|
|
n_comment varchar(152)
|
|
);
|
|
\copy public.nation_local FROM STDIN with delimiter '|';
|
|
CREATE TABLE test_schema_support.nation_append(
|
|
n_nationkey integer not null,
|
|
n_name char(25) not null,
|
|
n_regionkey integer not null,
|
|
n_comment varchar(152)
|
|
);
|
|
SELECT master_create_distributed_table('test_schema_support.nation_append', 'n_nationkey', 'append');
|
|
master_create_distributed_table
|
|
---------------------------------------------------------------------
|
|
|
|
(1 row)
|
|
|
|
SELECT master_create_empty_shard('test_schema_support.nation_append');
|
|
master_create_empty_shard
|
|
---------------------------------------------------------------------
|
|
1190000
|
|
(1 row)
|
|
|
|
-- append table to shard
|
|
SELECT master_append_table_to_shard(1190000, 'public.nation_local', 'localhost', :master_port);
|
|
master_append_table_to_shard
|
|
---------------------------------------------------------------------
|
|
0.00533333
|
|
(1 row)
|
|
|
|
-- verify table actually appended to shard
|
|
SELECT COUNT(*) FROM test_schema_support.nation_append;
|
|
count
|
|
---------------------------------------------------------------------
|
|
6
|
|
(1 row)
|
|
|
|
-- test with shard name contains special characters
|
|
CREATE TABLE test_schema_support."nation._'append" (
|
|
n_nationkey integer not null,
|
|
n_name char(25) not null,
|
|
n_regionkey integer not null,
|
|
n_comment varchar(152));
|
|
SELECT master_create_distributed_table('test_schema_support."nation._''append"', 'n_nationkey', 'append');
|
|
master_create_distributed_table
|
|
---------------------------------------------------------------------
|
|
|
|
(1 row)
|
|
|
|
SELECT master_create_empty_shard('test_schema_support."nation._''append"');
|
|
master_create_empty_shard
|
|
---------------------------------------------------------------------
|
|
1190001
|
|
(1 row)
|
|
|
|
SELECT master_append_table_to_shard(1190001, 'nation_local', 'localhost', :master_port);
|
|
master_append_table_to_shard
|
|
---------------------------------------------------------------------
|
|
0.00533333
|
|
(1 row)
|
|
|
|
-- verify table actually appended to shard
|
|
SELECT COUNT(*) FROM test_schema_support."nation._'append";
|
|
count
|
|
---------------------------------------------------------------------
|
|
6
|
|
(1 row)
|
|
|
|
-- test master_append_table_to_shard with schema with search_path is set
|
|
SET search_path TO test_schema_support;
|
|
SELECT master_append_table_to_shard(1190000, 'public.nation_local', 'localhost', :master_port);
|
|
master_append_table_to_shard
|
|
---------------------------------------------------------------------
|
|
0.00533333
|
|
(1 row)
|
|
|
|
-- verify table actually appended to shard
|
|
SELECT COUNT(*) FROM nation_append;
|
|
count
|
|
---------------------------------------------------------------------
|
|
12
|
|
(1 row)
|
|
|
|
-- test with search_path is set and shard name contains special characters
|
|
SELECT master_append_table_to_shard(1190001, 'nation_local', 'localhost', :master_port);
|
|
master_append_table_to_shard
|
|
---------------------------------------------------------------------
|
|
0.00533333
|
|
(1 row)
|
|
|
|
-- verify table actually appended to shard
|
|
SELECT COUNT(*) FROM "nation._'append";
|
|
count
|
|
---------------------------------------------------------------------
|
|
12
|
|
(1 row)
|
|
|
|
-- test shard creation on append(by data loading) and hash distributed(with UDF) tables
|
|
-- when search_path is set
|
|
SET search_path TO test_schema_support;
|
|
-- create shard with COPY on append distributed table
|
|
CREATE TABLE nation_append_search_path(
|
|
n_nationkey integer not null,
|
|
n_name char(25) not null,
|
|
n_regionkey integer not null,
|
|
n_comment varchar(152)
|
|
);
|
|
SELECT master_create_distributed_table('nation_append_search_path', 'n_nationkey', 'append');
|
|
master_create_distributed_table
|
|
---------------------------------------------------------------------
|
|
|
|
(1 row)
|
|
|
|
\copy nation_append_search_path FROM STDIN with delimiter '|';
|
|
-- create shard with master_create_worker_shards
|
|
CREATE TABLE test_schema_support.nation_hash(
|
|
n_nationkey integer not null,
|
|
n_name char(25) not null,
|
|
n_regionkey integer not null,
|
|
n_comment varchar(152)
|
|
);
|
|
SELECT master_create_distributed_table('test_schema_support.nation_hash', 'n_nationkey', 'hash');
|
|
master_create_distributed_table
|
|
---------------------------------------------------------------------
|
|
|
|
(1 row)
|
|
|
|
SELECT master_create_worker_shards('test_schema_support.nation_hash', 4, 2);
|
|
master_create_worker_shards
|
|
---------------------------------------------------------------------
|
|
|
|
(1 row)
|
|
|
|
-- test cursors
|
|
SET search_path TO public;
|
|
BEGIN;
|
|
DECLARE test_cursor CURSOR FOR
|
|
SELECT *
|
|
FROM test_schema_support.nation_append
|
|
WHERE n_nationkey = 1;
|
|
FETCH test_cursor;
|
|
n_nationkey | n_name | n_regionkey | n_comment
|
|
---------------------------------------------------------------------
|
|
1 | ARGENTINA | 1 | al foxes promise slyly according to the regular accounts. bold requests alon
|
|
(1 row)
|
|
|
|
FETCH test_cursor;
|
|
n_nationkey | n_name | n_regionkey | n_comment
|
|
---------------------------------------------------------------------
|
|
1 | ARGENTINA | 1 | al foxes promise slyly according to the regular accounts. bold requests alon
|
|
(1 row)
|
|
|
|
FETCH BACKWARD test_cursor;
|
|
n_nationkey | n_name | n_regionkey | n_comment
|
|
---------------------------------------------------------------------
|
|
1 | ARGENTINA | 1 | al foxes promise slyly according to the regular accounts. bold requests alon
|
|
(1 row)
|
|
|
|
END;
|
|
-- test with search_path is set
|
|
SET search_path TO test_schema_support;
|
|
BEGIN;
|
|
DECLARE test_cursor CURSOR FOR
|
|
SELECT *
|
|
FROM nation_append
|
|
WHERE n_nationkey = 1;
|
|
FETCH test_cursor;
|
|
n_nationkey | n_name | n_regionkey | n_comment
|
|
---------------------------------------------------------------------
|
|
1 | ARGENTINA | 1 | al foxes promise slyly according to the regular accounts. bold requests alon
|
|
(1 row)
|
|
|
|
FETCH test_cursor;
|
|
n_nationkey | n_name | n_regionkey | n_comment
|
|
---------------------------------------------------------------------
|
|
1 | ARGENTINA | 1 | al foxes promise slyly according to the regular accounts. bold requests alon
|
|
(1 row)
|
|
|
|
FETCH BACKWARD test_cursor;
|
|
n_nationkey | n_name | n_regionkey | n_comment
|
|
---------------------------------------------------------------------
|
|
1 | ARGENTINA | 1 | al foxes promise slyly according to the regular accounts. bold requests alon
|
|
(1 row)
|
|
|
|
END;
|
|
-- test inserting to table in different schema
|
|
SET search_path TO public;
|
|
INSERT INTO test_schema_support.nation_hash(n_nationkey, n_name, n_regionkey) VALUES (6, 'FRANCE', 3);
|
|
-- verify insertion
|
|
SELECT * FROM test_schema_support.nation_hash WHERE n_nationkey = 6;
|
|
n_nationkey | n_name | n_regionkey | n_comment
|
|
---------------------------------------------------------------------
|
|
6 | FRANCE | 3 |
|
|
(1 row)
|
|
|
|
-- test with search_path is set
|
|
SET search_path TO test_schema_support;
|
|
INSERT INTO nation_hash(n_nationkey, n_name, n_regionkey) VALUES (7, 'GERMANY', 3);
|
|
-- verify insertion
|
|
SELECT * FROM nation_hash WHERE n_nationkey = 7;
|
|
n_nationkey | n_name | n_regionkey | n_comment
|
|
---------------------------------------------------------------------
|
|
7 | GERMANY | 3 |
|
|
(1 row)
|
|
|
|
-- test UDFs with schemas
|
|
SET search_path TO public;
|
|
\copy test_schema_support.nation_hash FROM STDIN with delimiter '|';
|
|
-- create UDF in master node
|
|
CREATE OR REPLACE FUNCTION dummyFunction(theValue integer)
|
|
RETURNS text AS
|
|
$$
|
|
DECLARE
|
|
strresult text;
|
|
BEGIN
|
|
RETURN theValue * 3 / 2 + 1;
|
|
END;
|
|
$$
|
|
LANGUAGE 'plpgsql' IMMUTABLE;
|
|
-- create UDF in worker node 1
|
|
\c - - - :worker_1_port
|
|
CREATE OR REPLACE FUNCTION dummyFunction(theValue integer)
|
|
RETURNS text AS
|
|
$$
|
|
DECLARE
|
|
strresult text;
|
|
BEGIN
|
|
RETURN theValue * 3 / 2 + 1;
|
|
END;
|
|
$$
|
|
LANGUAGE 'plpgsql' IMMUTABLE;
|
|
-- create UDF in worker node 2
|
|
\c - - - :worker_2_port
|
|
CREATE OR REPLACE FUNCTION dummyFunction(theValue integer)
|
|
RETURNS text AS
|
|
$$
|
|
DECLARE
|
|
strresult text;
|
|
BEGIN
|
|
RETURN theValue * 3 / 2 + 1;
|
|
END;
|
|
$$
|
|
LANGUAGE 'plpgsql' IMMUTABLE;
|
|
\c - - - :master_port
|
|
-- UDF in public, table in a schema other than public, search_path is not set
|
|
SELECT dummyFunction(n_nationkey) FROM test_schema_support.nation_hash GROUP BY 1 ORDER BY 1;
|
|
dummyfunction
|
|
---------------------------------------------------------------------
|
|
1
|
|
10
|
|
11
|
|
2
|
|
4
|
|
5
|
|
7
|
|
8
|
|
(8 rows)
|
|
|
|
-- UDF in public, table in a schema other than public, search_path is set
|
|
SET search_path TO test_schema_support;
|
|
SELECT public.dummyFunction(n_nationkey) FROM test_schema_support.nation_hash GROUP BY 1 ORDER BY 1;
|
|
dummyfunction
|
|
---------------------------------------------------------------------
|
|
1
|
|
10
|
|
11
|
|
2
|
|
4
|
|
5
|
|
7
|
|
8
|
|
(8 rows)
|
|
|
|
-- create UDF in master node in schema
|
|
SET search_path TO test_schema_support;
|
|
CREATE OR REPLACE FUNCTION dummyFunction2(theValue integer)
|
|
RETURNS text AS
|
|
$$
|
|
DECLARE
|
|
strresult text;
|
|
BEGIN
|
|
RETURN theValue * 3 / 2 + 1;
|
|
END;
|
|
$$
|
|
LANGUAGE 'plpgsql' IMMUTABLE;
|
|
-- create UDF in worker node 1 in schema
|
|
\c - - - :worker_1_port
|
|
SET search_path TO test_schema_support;
|
|
CREATE OR REPLACE FUNCTION dummyFunction2(theValue integer)
|
|
RETURNS text AS
|
|
$$
|
|
DECLARE
|
|
strresult text;
|
|
BEGIN
|
|
RETURN theValue * 3 / 2 + 1;
|
|
END;
|
|
$$
|
|
LANGUAGE 'plpgsql' IMMUTABLE;
|
|
-- create UDF in worker node 2 in schema
|
|
\c - - - :worker_2_port
|
|
SET search_path TO test_schema_support;
|
|
CREATE OR REPLACE FUNCTION dummyFunction2(theValue integer)
|
|
RETURNS text AS
|
|
$$
|
|
DECLARE
|
|
strresult text;
|
|
BEGIN
|
|
RETURN theValue * 3 / 2 + 1;
|
|
END;
|
|
$$
|
|
LANGUAGE 'plpgsql' IMMUTABLE;
|
|
\c - - - :master_port
|
|
-- UDF in schema, table in a schema other than public, search_path is not set
|
|
SET search_path TO public;
|
|
SELECT test_schema_support.dummyFunction2(n_nationkey) FROM test_schema_support.nation_hash GROUP BY 1 ORDER BY 1;
|
|
dummyfunction2
|
|
---------------------------------------------------------------------
|
|
1
|
|
10
|
|
11
|
|
2
|
|
4
|
|
5
|
|
7
|
|
8
|
|
(8 rows)
|
|
|
|
-- UDF in schema, table in a schema other than public, search_path is set
|
|
SET search_path TO test_schema_support;
|
|
SELECT dummyFunction2(n_nationkey) FROM nation_hash GROUP BY 1 ORDER BY 1;
|
|
dummyfunction2
|
|
---------------------------------------------------------------------
|
|
1
|
|
10
|
|
11
|
|
2
|
|
4
|
|
5
|
|
7
|
|
8
|
|
(8 rows)
|
|
|
|
-- test operators with schema
|
|
SET search_path TO public;
|
|
-- create operator in master
|
|
CREATE OPERATOR test_schema_support.=== (
|
|
LEFTARG = int,
|
|
RIGHTARG = int,
|
|
PROCEDURE = int4eq,
|
|
COMMUTATOR = ===,
|
|
NEGATOR = !==,
|
|
HASHES, MERGES
|
|
);
|
|
-- create operator in worker node 1
|
|
\c - - - :worker_1_port
|
|
CREATE OPERATOR test_schema_support.=== (
|
|
LEFTARG = int,
|
|
RIGHTARG = int,
|
|
PROCEDURE = int4eq,
|
|
COMMUTATOR = ===,
|
|
NEGATOR = !==,
|
|
HASHES, MERGES
|
|
);
|
|
-- create operator in worker node 2
|
|
\c - - - :worker_2_port
|
|
CREATE OPERATOR test_schema_support.=== (
|
|
LEFTARG = int,
|
|
RIGHTARG = int,
|
|
PROCEDURE = int4eq,
|
|
COMMUTATOR = ===,
|
|
NEGATOR = !==,
|
|
HASHES, MERGES
|
|
);
|
|
\c - - - :master_port
|
|
-- test with search_path is not set
|
|
SELECT * FROM test_schema_support.nation_hash WHERE n_nationkey OPERATOR(test_schema_support.===) 1;
|
|
n_nationkey | n_name | n_regionkey | n_comment
|
|
---------------------------------------------------------------------
|
|
1 | ARGENTINA | 1 | al foxes promise slyly according to the regular accounts. bold requests alon
|
|
(1 row)
|
|
|
|
-- test with search_path is set
|
|
SET search_path TO test_schema_support;
|
|
SELECT * FROM nation_hash WHERE n_nationkey OPERATOR(===) 1;
|
|
n_nationkey | n_name | n_regionkey | n_comment
|
|
---------------------------------------------------------------------
|
|
1 | ARGENTINA | 1 | al foxes promise slyly according to the regular accounts. bold requests alon
|
|
(1 row)
|
|
|
|
-- test with multi-shard DML
|
|
SET search_path TO public;
|
|
UPDATE test_schema_support.nation_hash SET n_regionkey = n_regionkey + 1;
|
|
--verify modification
|
|
SELECT * FROM test_schema_support.nation_hash ORDER BY 1,2,3,4;
|
|
n_nationkey | n_name | n_regionkey | n_comment
|
|
---------------------------------------------------------------------
|
|
0 | ALGERIA | 1 | haggle. carefully final deposits detect slyly agai
|
|
1 | ARGENTINA | 2 | al foxes promise slyly according to the regular accounts. bold requests alon
|
|
2 | BRAZIL | 2 | y alongside of the pending deposits. carefully special packages are about the ironic forges. slyly special
|
|
3 | CANADA | 2 | eas hang ironic, silent packages. slyly regular packages are furiously over the tithes. fluffily bold
|
|
4 | EGYPT | 5 | y above the carefully unusual theodolites. final dugouts are quickly across the furiously regular d
|
|
5 | ETHIOPIA | 1 | ven packages wake quickly. regu
|
|
6 | FRANCE | 4 |
|
|
7 | GERMANY | 4 |
|
|
(8 rows)
|
|
|
|
--test with search_path is set
|
|
SET search_path TO test_schema_support;
|
|
UPDATE nation_hash SET n_regionkey = n_regionkey + 1;
|
|
--verify modification
|
|
SELECT * FROM nation_hash ORDER BY 1,2,3,4;
|
|
n_nationkey | n_name | n_regionkey | n_comment
|
|
---------------------------------------------------------------------
|
|
0 | ALGERIA | 2 | haggle. carefully final deposits detect slyly agai
|
|
1 | ARGENTINA | 3 | al foxes promise slyly according to the regular accounts. bold requests alon
|
|
2 | BRAZIL | 3 | y alongside of the pending deposits. carefully special packages are about the ironic forges. slyly special
|
|
3 | CANADA | 3 | eas hang ironic, silent packages. slyly regular packages are furiously over the tithes. fluffily bold
|
|
4 | EGYPT | 6 | y above the carefully unusual theodolites. final dugouts are quickly across the furiously regular d
|
|
5 | ETHIOPIA | 2 | ven packages wake quickly. regu
|
|
6 | FRANCE | 5 |
|
|
7 | GERMANY | 5 |
|
|
(8 rows)
|
|
|
|
--test COLLATION with schema
|
|
SET search_path TO public;
|
|
SELECT quote_ident(current_setting('lc_collate')) as current_locale \gset
|
|
CREATE COLLATION test_schema_support.english (LOCALE = :current_locale);
|
|
\c - - - :master_port
|
|
CREATE TABLE test_schema_support.nation_hash_collation(
|
|
n_nationkey integer not null,
|
|
n_name char(25) not null COLLATE test_schema_support.english,
|
|
n_regionkey integer not null,
|
|
n_comment varchar(152)
|
|
);
|
|
SELECT master_get_table_ddl_events('test_schema_support.nation_hash_collation') ORDER BY 1;
|
|
master_get_table_ddl_events
|
|
---------------------------------------------------------------------
|
|
ALTER TABLE test_schema_support.nation_hash_collation OWNER TO postgres
|
|
CREATE TABLE test_schema_support.nation_hash_collation (n_nationkey integer NOT NULL, n_name character(25) NOT NULL COLLATE test_schema_support.english, n_regionkey integer NOT NULL, n_comment character varying(152))
|
|
(2 rows)
|
|
|
|
SELECT master_create_distributed_table('test_schema_support.nation_hash_collation', 'n_nationkey', 'hash');
|
|
master_create_distributed_table
|
|
---------------------------------------------------------------------
|
|
|
|
(1 row)
|
|
|
|
SELECT master_create_worker_shards('test_schema_support.nation_hash_collation', 4, 2);
|
|
master_create_worker_shards
|
|
---------------------------------------------------------------------
|
|
|
|
(1 row)
|
|
|
|
\copy test_schema_support.nation_hash_collation FROM STDIN with delimiter '|';
|
|
SELECT * FROM test_schema_support.nation_hash_collation ORDER BY 1,2,3,4;
|
|
n_nationkey | n_name | n_regionkey | n_comment
|
|
---------------------------------------------------------------------
|
|
0 | ALGERIA | 0 | haggle. carefully final deposits detect slyly agai
|
|
1 | ARGENTINA | 1 | al foxes promise slyly according to the regular accounts. bold requests alon
|
|
2 | BRAZIL | 1 | y alongside of the pending deposits. carefully special packages are about the ironic forges. slyly special
|
|
3 | CANADA | 1 | eas hang ironic, silent packages. slyly regular packages are furiously over the tithes. fluffily bold
|
|
4 | EGYPT | 4 | y above the carefully unusual theodolites. final dugouts are quickly across the furiously regular d
|
|
5 | ETHIOPIA | 0 | ven packages wake quickly. regu
|
|
(6 rows)
|
|
|
|
SELECT n_comment FROM test_schema_support.nation_hash_collation ORDER BY n_comment COLLATE test_schema_support.english;
|
|
n_comment
|
|
---------------------------------------------------------------------
|
|
al foxes promise slyly according to the regular accounts. bold requests alon
|
|
eas hang ironic, silent packages. slyly regular packages are furiously over the tithes. fluffily bold
|
|
haggle. carefully final deposits detect slyly agai
|
|
ven packages wake quickly. regu
|
|
y above the carefully unusual theodolites. final dugouts are quickly across the furiously regular d
|
|
y alongside of the pending deposits. carefully special packages are about the ironic forges. slyly special
|
|
(6 rows)
|
|
|
|
--test with search_path is set
|
|
SET search_path TO test_schema_support;
|
|
CREATE TABLE nation_hash_collation_search_path(
|
|
n_nationkey integer not null,
|
|
n_name char(25) not null COLLATE english,
|
|
n_regionkey integer not null,
|
|
n_comment varchar(152)
|
|
);
|
|
SELECT master_create_distributed_table('nation_hash_collation_search_path', 'n_nationkey', 'hash');
|
|
master_create_distributed_table
|
|
---------------------------------------------------------------------
|
|
|
|
(1 row)
|
|
|
|
SELECT master_create_worker_shards('nation_hash_collation_search_path', 4, 2);
|
|
master_create_worker_shards
|
|
---------------------------------------------------------------------
|
|
|
|
(1 row)
|
|
|
|
\copy nation_hash_collation_search_path FROM STDIN with delimiter '|';
|
|
SELECT * FROM nation_hash_collation_search_path ORDER BY 1 DESC, 2 DESC, 3 DESC, 4 DESC;
|
|
n_nationkey | n_name | n_regionkey | n_comment
|
|
---------------------------------------------------------------------
|
|
5 | ETHIOPIA | 0 | ven packages wake quickly. regu
|
|
4 | EGYPT | 4 | y above the carefully unusual theodolites. final dugouts are quickly across the furiously regular d
|
|
3 | CANADA | 1 | eas hang ironic, silent packages. slyly regular packages are furiously over the tithes. fluffily bold
|
|
2 | BRAZIL | 1 | y alongside of the pending deposits. carefully special packages are about the ironic forges. slyly special
|
|
1 | ARGENTINA | 1 | al foxes promise slyly according to the regular accounts. bold requests alon
|
|
0 | ALGERIA | 0 | haggle. carefully final deposits detect slyly agai
|
|
(6 rows)
|
|
|
|
SELECT n_comment FROM nation_hash_collation_search_path ORDER BY n_comment COLLATE english;
|
|
n_comment
|
|
---------------------------------------------------------------------
|
|
al foxes promise slyly according to the regular accounts. bold requests alon
|
|
eas hang ironic, silent packages. slyly regular packages are furiously over the tithes. fluffily bold
|
|
haggle. carefully final deposits detect slyly agai
|
|
ven packages wake quickly. regu
|
|
y above the carefully unusual theodolites. final dugouts are quickly across the furiously regular d
|
|
y alongside of the pending deposits. carefully special packages are about the ironic forges. slyly special
|
|
(6 rows)
|
|
|
|
--test composite types with schema
|
|
SET search_path TO public;
|
|
CREATE TYPE test_schema_support.new_composite_type as (key1 text, key2 text);
|
|
CREATE TABLE test_schema_support.nation_hash_composite_types(
|
|
n_nationkey integer not null,
|
|
n_name char(25) not null,
|
|
n_regionkey integer not null,
|
|
n_comment varchar(152),
|
|
test_col test_schema_support.new_composite_type
|
|
);
|
|
SELECT master_create_distributed_table('test_schema_support.nation_hash_composite_types', 'n_nationkey', 'hash');
|
|
master_create_distributed_table
|
|
---------------------------------------------------------------------
|
|
|
|
(1 row)
|
|
|
|
SELECT master_create_worker_shards('test_schema_support.nation_hash_composite_types', 4, 2);
|
|
master_create_worker_shards
|
|
---------------------------------------------------------------------
|
|
|
|
(1 row)
|
|
|
|
-- insert some data to verify composite type queries
|
|
\copy test_schema_support.nation_hash_composite_types FROM STDIN with delimiter '|';
|
|
SELECT * FROM test_schema_support.nation_hash_composite_types WHERE test_col = '(a,a)'::test_schema_support.new_composite_type;
|
|
n_nationkey | n_name | n_regionkey | n_comment | test_col
|
|
---------------------------------------------------------------------
|
|
0 | ALGERIA | 0 | haggle. carefully final deposits detect slyly agai | (a,a)
|
|
(1 row)
|
|
|
|
--test with search_path is set
|
|
SET search_path TO test_schema_support;
|
|
SELECT * FROM nation_hash_composite_types WHERE test_col = '(a,a)'::new_composite_type;
|
|
n_nationkey | n_name | n_regionkey | n_comment | test_col
|
|
---------------------------------------------------------------------
|
|
0 | ALGERIA | 0 | haggle. carefully final deposits detect slyly agai | (a,a)
|
|
(1 row)
|
|
|
|
-- test ALTER TABLE ADD/DROP queries with schemas
|
|
SET search_path TO public;
|
|
ALTER TABLE test_schema_support.nation_hash ADD COLUMN new_col INT;
|
|
-- verify column is added
|
|
SELECT "Column", "Type", "Modifiers" FROM table_desc WHERE relid='test_schema_support.nation_hash'::regclass;
|
|
Column | Type | Modifiers
|
|
---------------------------------------------------------------------
|
|
n_nationkey | integer | not null
|
|
n_name | character(25) | not null
|
|
n_regionkey | integer | not null
|
|
n_comment | character varying(152) |
|
|
new_col | integer |
|
|
(5 rows)
|
|
|
|
\c - - - :worker_1_port
|
|
SELECT "Column", "Type", "Modifiers" FROM table_desc WHERE relid='test_schema_support.nation_hash_1190003'::regclass;
|
|
Column | Type | Modifiers
|
|
---------------------------------------------------------------------
|
|
n_nationkey | integer | not null
|
|
n_name | character(25) | not null
|
|
n_regionkey | integer | not null
|
|
n_comment | character varying(152) |
|
|
new_col | integer |
|
|
(5 rows)
|
|
|
|
\c - - - :master_port
|
|
ALTER TABLE test_schema_support.nation_hash DROP COLUMN IF EXISTS non_existent_column;
|
|
NOTICE: column "non_existent_column" of relation "nation_hash" does not exist, skipping
|
|
ALTER TABLE test_schema_support.nation_hash DROP COLUMN IF EXISTS new_col;
|
|
-- verify column is dropped
|
|
SELECT "Column", "Type", "Modifiers" FROM table_desc WHERE relid='test_schema_support.nation_hash'::regclass;
|
|
Column | Type | Modifiers
|
|
---------------------------------------------------------------------
|
|
n_nationkey | integer | not null
|
|
n_name | character(25) | not null
|
|
n_regionkey | integer | not null
|
|
n_comment | character varying(152) |
|
|
(4 rows)
|
|
|
|
\c - - - :worker_1_port
|
|
SELECT "Column", "Type", "Modifiers" FROM table_desc WHERE relid='test_schema_support.nation_hash_1190003'::regclass;
|
|
Column | Type | Modifiers
|
|
---------------------------------------------------------------------
|
|
n_nationkey | integer | not null
|
|
n_name | character(25) | not null
|
|
n_regionkey | integer | not null
|
|
n_comment | character varying(152) |
|
|
(4 rows)
|
|
|
|
\c - - - :master_port
|
|
--test with search_path is set
|
|
SET search_path TO test_schema_support;
|
|
ALTER TABLE nation_hash ADD COLUMN new_col INT;
|
|
-- verify column is added
|
|
SELECT "Column", "Type", "Modifiers" FROM public.table_desc WHERE relid='test_schema_support.nation_hash'::regclass;
|
|
Column | Type | Modifiers
|
|
---------------------------------------------------------------------
|
|
n_nationkey | integer | not null
|
|
n_name | character(25) | not null
|
|
n_regionkey | integer | not null
|
|
n_comment | character varying(152) |
|
|
new_col | integer |
|
|
(5 rows)
|
|
|
|
\c - - - :worker_1_port
|
|
SELECT "Column", "Type", "Modifiers" FROM public.table_desc WHERE relid='test_schema_support.nation_hash_1190003'::regclass;
|
|
Column | Type | Modifiers
|
|
---------------------------------------------------------------------
|
|
n_nationkey | integer | not null
|
|
n_name | character(25) | not null
|
|
n_regionkey | integer | not null
|
|
n_comment | character varying(152) |
|
|
new_col | integer |
|
|
(5 rows)
|
|
|
|
\c - - - :master_port
|
|
SET search_path TO test_schema_support;
|
|
ALTER TABLE nation_hash DROP COLUMN IF EXISTS non_existent_column;
|
|
NOTICE: column "non_existent_column" of relation "nation_hash" does not exist, skipping
|
|
ALTER TABLE nation_hash DROP COLUMN IF EXISTS new_col;
|
|
-- verify column is dropped
|
|
SELECT "Column", "Type", "Modifiers" FROM public.table_desc WHERE relid='test_schema_support.nation_hash'::regclass;
|
|
Column | Type | Modifiers
|
|
---------------------------------------------------------------------
|
|
n_nationkey | integer | not null
|
|
n_name | character(25) | not null
|
|
n_regionkey | integer | not null
|
|
n_comment | character varying(152) |
|
|
(4 rows)
|
|
|
|
\c - - - :worker_1_port
|
|
SELECT "Column", "Type", "Modifiers" FROM public.table_desc WHERE relid='test_schema_support.nation_hash_1190003'::regclass;
|
|
Column | Type | Modifiers
|
|
---------------------------------------------------------------------
|
|
n_nationkey | integer | not null
|
|
n_name | character(25) | not null
|
|
n_regionkey | integer | not null
|
|
n_comment | character varying(152) |
|
|
(4 rows)
|
|
|
|
\c - - - :master_port
|
|
-- test CREATE/DROP INDEX with schemas
|
|
SET search_path TO public;
|
|
-- CREATE index
|
|
CREATE INDEX index1 ON test_schema_support.nation_hash(n_name);
|
|
--verify INDEX is created
|
|
SELECT "Column", "Type", "Definition" FROM index_attrs WHERE
|
|
relid = 'test_schema_support.index1'::regclass;
|
|
Column | Type | Definition
|
|
---------------------------------------------------------------------
|
|
n_name | character(25) | n_name
|
|
(1 row)
|
|
|
|
\c - - - :worker_1_port
|
|
SELECT "Column", "Type", "Definition" FROM index_attrs WHERE
|
|
relid = 'test_schema_support.index1_1190003'::regclass;
|
|
Column | Type | Definition
|
|
---------------------------------------------------------------------
|
|
n_name | character(25) | n_name
|
|
(1 row)
|
|
|
|
\c - - - :master_port
|
|
-- DROP index
|
|
DROP INDEX test_schema_support.index1;
|
|
--verify INDEX is dropped
|
|
\d test_schema_support.index1
|
|
\c - - - :worker_1_port
|
|
\d test_schema_support.index1_1190003
|
|
\c - - - :master_port
|
|
--test with search_path is set
|
|
SET search_path TO test_schema_support;
|
|
-- CREATE index
|
|
CREATE INDEX index1 ON nation_hash(n_name);
|
|
--verify INDEX is created
|
|
SELECT "Column", "Type", "Definition" FROM public.index_attrs WHERE
|
|
relid = 'test_schema_support.index1'::regclass;
|
|
Column | Type | Definition
|
|
---------------------------------------------------------------------
|
|
n_name | character(25) | n_name
|
|
(1 row)
|
|
|
|
\c - - - :worker_1_port
|
|
SELECT "Column", "Type", "Definition" FROM index_attrs WHERE
|
|
relid = 'test_schema_support.index1_1190003'::regclass;
|
|
Column | Type | Definition
|
|
---------------------------------------------------------------------
|
|
n_name | character(25) | n_name
|
|
(1 row)
|
|
|
|
\c - - - :master_port
|
|
-- DROP index
|
|
SET search_path TO test_schema_support;
|
|
DROP INDEX index1;
|
|
--verify INDEX is dropped
|
|
\d test_schema_support.index1
|
|
\c - - - :worker_1_port
|
|
\d test_schema_support.index1_1190003
|
|
\c - - - :master_port
|
|
-- test master_copy_shard_placement with schemas
|
|
SET search_path TO public;
|
|
-- mark shard as inactive
|
|
UPDATE pg_dist_shard_placement SET shardstate = 3 WHERE shardid = 1190000 and nodeport = :worker_1_port;
|
|
SELECT master_copy_shard_placement(1190000, 'localhost', :worker_2_port, 'localhost', :worker_1_port);
|
|
master_copy_shard_placement
|
|
---------------------------------------------------------------------
|
|
|
|
(1 row)
|
|
|
|
-- verify shardstate
|
|
SELECT shardstate, nodename, nodeport FROM pg_dist_shard_placement WHERE shardid = 1190000 ORDER BY nodeport;
|
|
shardstate | nodename | nodeport
|
|
---------------------------------------------------------------------
|
|
1 | localhost | 57637
|
|
1 | localhost | 57638
|
|
(2 rows)
|
|
|
|
--test with search_path is set
|
|
SET search_path TO test_schema_support;
|
|
-- mark shard as inactive
|
|
UPDATE pg_dist_shard_placement SET shardstate = 3 WHERE shardid = 1190000 and nodeport = :worker_1_port;
|
|
SELECT master_copy_shard_placement(1190000, 'localhost', :worker_2_port, 'localhost', :worker_1_port);
|
|
master_copy_shard_placement
|
|
---------------------------------------------------------------------
|
|
|
|
(1 row)
|
|
|
|
-- verify shardstate
|
|
SELECT shardstate, nodename, nodeport FROM pg_dist_shard_placement WHERE shardid = 1190000 ORDER BY nodeport;
|
|
shardstate | nodename | nodeport
|
|
---------------------------------------------------------------------
|
|
1 | localhost | 57637
|
|
1 | localhost | 57638
|
|
(2 rows)
|
|
|
|
-- test master_apply_delete_command with schemas
|
|
SET search_path TO public;
|
|
SELECT master_apply_delete_command('DELETE FROM test_schema_support.nation_append') ;
|
|
master_apply_delete_command
|
|
---------------------------------------------------------------------
|
|
1
|
|
(1 row)
|
|
|
|
-- verify shard is dropped
|
|
\c - - - :worker_1_port
|
|
\d test_schema_support.nation_append_119*
|
|
\c - - - :master_port
|
|
-- test with search_path is set
|
|
SET search_path TO test_schema_support;
|
|
\copy nation_append FROM STDIN with delimiter '|';
|
|
SELECT master_apply_delete_command('DELETE FROM nation_append') ;
|
|
master_apply_delete_command
|
|
---------------------------------------------------------------------
|
|
1
|
|
(1 row)
|
|
|
|
-- verify shard is dropped
|
|
\c - - - :worker_1_port
|
|
\d test_schema_support.nation_append_119*
|
|
\c - - - :master_port
|
|
-- check joins of tables which are in schemas other than public
|
|
-- we create new tables with replication factor of 1
|
|
-- so that we guarantee to have repartitions when necessary
|
|
-- create necessary objects and load data to them
|
|
CREATE SCHEMA test_schema_support_join_1;
|
|
CREATE SCHEMA test_schema_support_join_2;
|
|
SET citus.shard_count to 4;
|
|
SET citus.shard_replication_factor to 1;
|
|
CREATE TABLE test_schema_support_join_1.nation_hash (
|
|
n_nationkey integer not null,
|
|
n_name char(25) not null,
|
|
n_regionkey integer not null,
|
|
n_comment varchar(152));
|
|
CREATE TABLE test_schema_support_join_1.nation_hash_2 (
|
|
n_nationkey integer not null,
|
|
n_name char(25) not null,
|
|
n_regionkey integer not null,
|
|
n_comment varchar(152));
|
|
CREATE TABLE test_schema_support_join_2.nation_hash (
|
|
n_nationkey integer not null,
|
|
n_name char(25) not null,
|
|
n_regionkey integer not null,
|
|
n_comment varchar(152));
|
|
SELECT create_distributed_table('test_schema_support_join_1.nation_hash', 'n_nationkey');
|
|
create_distributed_table
|
|
---------------------------------------------------------------------
|
|
|
|
(1 row)
|
|
|
|
\copy test_schema_support_join_1.nation_hash FROM STDIN with delimiter '|';
|
|
SELECT create_distributed_table('test_schema_support_join_1.nation_hash_2', 'n_nationkey');
|
|
create_distributed_table
|
|
---------------------------------------------------------------------
|
|
|
|
(1 row)
|
|
|
|
\copy test_schema_support_join_1.nation_hash_2 FROM STDIN with delimiter '|';
|
|
SELECT create_distributed_table('test_schema_support_join_2.nation_hash', 'n_nationkey');
|
|
create_distributed_table
|
|
---------------------------------------------------------------------
|
|
|
|
(1 row)
|
|
|
|
\copy test_schema_support_join_2.nation_hash FROM STDIN with delimiter '|';
|
|
-- check when search_path is public,
|
|
-- join of two tables which are in different schemas,
|
|
-- join on partition column
|
|
SET search_path TO public;
|
|
SELECT
|
|
count (*)
|
|
FROM
|
|
test_schema_support_join_1.nation_hash n1, test_schema_support_join_2.nation_hash n2
|
|
WHERE
|
|
n1.n_nationkey = n2.n_nationkey;
|
|
count
|
|
---------------------------------------------------------------------
|
|
6
|
|
(1 row)
|
|
|
|
-- check when search_path is different than public,
|
|
-- join of two tables which are in different schemas,
|
|
-- join on partition column
|
|
SET search_path TO test_schema_support_join_1;
|
|
SELECT
|
|
count (*)
|
|
FROM
|
|
nation_hash n1, test_schema_support_join_2.nation_hash n2
|
|
WHERE
|
|
n1.n_nationkey = n2.n_nationkey;
|
|
count
|
|
---------------------------------------------------------------------
|
|
6
|
|
(1 row)
|
|
|
|
-- check when search_path is public,
|
|
-- join of two tables which are in same schemas,
|
|
-- join on partition column
|
|
SET search_path TO public;
|
|
SELECT
|
|
count (*)
|
|
FROM
|
|
test_schema_support_join_1.nation_hash n1, test_schema_support_join_1.nation_hash_2 n2
|
|
WHERE
|
|
n1.n_nationkey = n2.n_nationkey;
|
|
count
|
|
---------------------------------------------------------------------
|
|
6
|
|
(1 row)
|
|
|
|
-- check when search_path is different than public,
|
|
-- join of two tables which are in same schemas,
|
|
-- join on partition column
|
|
SET search_path TO test_schema_support_join_1;
|
|
SELECT
|
|
count (*)
|
|
FROM
|
|
nation_hash n1, nation_hash_2 n2
|
|
WHERE
|
|
n1.n_nationkey = n2.n_nationkey;
|
|
count
|
|
---------------------------------------------------------------------
|
|
6
|
|
(1 row)
|
|
|
|
-- single repartition joins
|
|
SET citus.task_executor_type TO "task-tracker";
|
|
-- check when search_path is public,
|
|
-- join of two tables which are in different schemas,
|
|
-- join on partition column and non-partition column
|
|
SET search_path TO public;
|
|
SELECT
|
|
count (*)
|
|
FROM
|
|
test_schema_support_join_1.nation_hash n1, test_schema_support_join_2.nation_hash n2
|
|
WHERE
|
|
n1.n_nationkey = n2.n_regionkey;
|
|
count
|
|
---------------------------------------------------------------------
|
|
6
|
|
(1 row)
|
|
|
|
-- check when search_path is different than public,
|
|
-- join of two tables which are in different schemas,
|
|
-- join on partition column and non-partition column
|
|
SET search_path TO test_schema_support_join_1;
|
|
SELECT
|
|
count (*)
|
|
FROM
|
|
nation_hash n1, test_schema_support_join_2.nation_hash n2
|
|
WHERE
|
|
n1.n_nationkey = n2.n_regionkey;
|
|
count
|
|
---------------------------------------------------------------------
|
|
6
|
|
(1 row)
|
|
|
|
-- check when search_path is different than public,
|
|
-- join of two tables which are in same schemas,
|
|
-- join on partition column and non-partition column
|
|
SET search_path TO test_schema_support_join_1;
|
|
SELECT
|
|
count (*)
|
|
FROM
|
|
nation_hash n1, nation_hash_2 n2
|
|
WHERE
|
|
n1.n_nationkey = n2.n_regionkey;
|
|
count
|
|
---------------------------------------------------------------------
|
|
6
|
|
(1 row)
|
|
|
|
-- hash repartition joins
|
|
-- check when search_path is public,
|
|
-- join of two tables which are in different schemas,
|
|
-- join on non-partition column
|
|
SET search_path TO public;
|
|
SELECT
|
|
count (*)
|
|
FROM
|
|
test_schema_support_join_1.nation_hash n1, test_schema_support_join_2.nation_hash n2
|
|
WHERE
|
|
n1.n_regionkey = n2.n_regionkey;
|
|
count
|
|
---------------------------------------------------------------------
|
|
14
|
|
(1 row)
|
|
|
|
-- check when search_path is different than public,
|
|
-- join of two tables which are in different schemas,
|
|
-- join on non-partition column
|
|
SET search_path TO test_schema_support_join_1;
|
|
SELECT
|
|
count (*)
|
|
FROM
|
|
nation_hash n1, test_schema_support_join_2.nation_hash n2
|
|
WHERE
|
|
n1.n_regionkey = n2.n_regionkey;
|
|
count
|
|
---------------------------------------------------------------------
|
|
14
|
|
(1 row)
|
|
|
|
-- check when search_path is different than public,
|
|
-- join of two tables which are in same schemas,
|
|
-- join on non-partition column
|
|
SET search_path TO test_schema_support_join_1;
|
|
SELECT
|
|
count (*)
|
|
FROM
|
|
nation_hash n1, nation_hash_2 n2
|
|
WHERE
|
|
n1.n_regionkey = n2.n_regionkey;
|
|
count
|
|
---------------------------------------------------------------------
|
|
14
|
|
(1 row)
|
|
|
|
-- set task_executor back to adaptive
|
|
SET citus.task_executor_type TO "adaptive";
|
|
-- test ALTER TABLE SET SCHEMA
|
|
SET search_path TO public;
|
|
CREATE SCHEMA old_schema;
|
|
CREATE TABLE old_schema.table_set_schema(id int);
|
|
SELECT create_distributed_table('old_schema.table_set_schema', 'id');
|
|
create_distributed_table
|
|
---------------------------------------------------------------------
|
|
|
|
(1 row)
|
|
|
|
CREATE SCHEMA new_schema;
|
|
SELECT objid::oid::regnamespace as "Distributed Schemas"
|
|
FROM citus.pg_dist_object
|
|
WHERE objid::oid::regnamespace IN ('old_schema', 'new_schema');
|
|
Distributed Schemas
|
|
---------------------------------------------------------------------
|
|
old_schema
|
|
(1 row)
|
|
|
|
\c - - - :worker_1_port
|
|
SELECT table_schema AS "Shards' Schema"
|
|
FROM information_schema.tables
|
|
WHERE table_name LIKE 'table\_set\_schema\_%' AND
|
|
table_schema IN ('old_schema', 'new_schema', 'public')
|
|
GROUP BY table_schema;
|
|
Shards' Schema
|
|
---------------------------------------------------------------------
|
|
old_schema
|
|
(1 row)
|
|
|
|
\c - - - :master_port
|
|
ALTER TABLE old_schema.table_set_schema SET SCHEMA new_schema;
|
|
SELECT objid::oid::regnamespace as "Distributed Schemas"
|
|
FROM citus.pg_dist_object
|
|
WHERE objid::oid::regnamespace IN ('old_schema', 'new_schema');
|
|
Distributed Schemas
|
|
---------------------------------------------------------------------
|
|
old_schema
|
|
new_schema
|
|
(2 rows)
|
|
|
|
\c - - - :worker_1_port
|
|
SELECT table_schema AS "Shards' Schema"
|
|
FROM information_schema.tables
|
|
WHERE table_name LIKE 'table\_set\_schema\_%' AND
|
|
table_schema IN ('old_schema', 'new_schema', 'public')
|
|
GROUP BY table_schema;
|
|
Shards' Schema
|
|
---------------------------------------------------------------------
|
|
new_schema
|
|
(1 row)
|
|
|
|
\c - - - :master_port
|
|
SELECT * FROM new_schema.table_set_schema;
|
|
id
|
|
---------------------------------------------------------------------
|
|
(0 rows)
|
|
|
|
DROP SCHEMA old_schema CASCADE;
|
|
DROP SCHEMA new_schema CASCADE;
|
|
NOTICE: drop cascades to table new_schema.table_set_schema
|
|
-- test ALTER TABLE SET SCHEMA from public
|
|
CREATE TABLE table_set_schema(id int);
|
|
SELECT create_distributed_table('table_set_schema', 'id');
|
|
create_distributed_table
|
|
---------------------------------------------------------------------
|
|
|
|
(1 row)
|
|
|
|
CREATE SCHEMA new_schema;
|
|
SELECT objid::oid::regnamespace as "Distributed Schemas"
|
|
FROM citus.pg_dist_object
|
|
WHERE objid='new_schema'::regnamespace::oid;
|
|
Distributed Schemas
|
|
---------------------------------------------------------------------
|
|
(0 rows)
|
|
|
|
\c - - - :worker_1_port
|
|
SELECT table_schema AS "Shards' Schema"
|
|
FROM information_schema.tables
|
|
WHERE table_name LIKE 'table\_set\_schema\_%' AND
|
|
table_schema IN ('new_schema', 'public')
|
|
GROUP BY table_schema;
|
|
Shards' Schema
|
|
---------------------------------------------------------------------
|
|
public
|
|
(1 row)
|
|
|
|
\c - - - :master_port
|
|
ALTER TABLE table_set_schema SET SCHEMA new_schema;
|
|
SELECT objid::oid::regnamespace as "Distributed Schemas"
|
|
FROM citus.pg_dist_object
|
|
WHERE objid='new_schema'::regnamespace::oid;
|
|
Distributed Schemas
|
|
---------------------------------------------------------------------
|
|
new_schema
|
|
(1 row)
|
|
|
|
\c - - - :worker_1_port
|
|
SELECT table_schema AS "Shards' Schema"
|
|
FROM information_schema.tables
|
|
WHERE table_name LIKE 'table\_set\_schema\_%' AND
|
|
table_schema IN ('new_schema', 'public')
|
|
GROUP BY table_schema;
|
|
Shards' Schema
|
|
---------------------------------------------------------------------
|
|
new_schema
|
|
(1 row)
|
|
|
|
\c - - - :master_port
|
|
SELECT * FROM new_schema.table_set_schema;
|
|
id
|
|
---------------------------------------------------------------------
|
|
(0 rows)
|
|
|
|
DROP SCHEMA new_schema CASCADE;
|
|
NOTICE: drop cascades to table new_schema.table_set_schema
|
|
-- test ALTER TABLE SET SCHEMA when a search path is set
|
|
CREATE SCHEMA old_schema;
|
|
CREATE TABLE old_schema.table_set_schema(id int);
|
|
SELECT create_distributed_table('old_schema.table_set_schema', 'id');
|
|
create_distributed_table
|
|
---------------------------------------------------------------------
|
|
|
|
(1 row)
|
|
|
|
CREATE TABLE table_set_schema(id int);
|
|
SELECT create_distributed_table('table_set_schema', 'id');
|
|
create_distributed_table
|
|
---------------------------------------------------------------------
|
|
|
|
(1 row)
|
|
|
|
CREATE SCHEMA new_schema;
|
|
SELECT objid::oid::regnamespace as "Distributed Schemas"
|
|
FROM citus.pg_dist_object
|
|
WHERE objid::oid::regnamespace IN ('old_schema', 'new_schema');
|
|
Distributed Schemas
|
|
---------------------------------------------------------------------
|
|
old_schema
|
|
(1 row)
|
|
|
|
\c - - - :worker_1_port
|
|
SELECT table_schema AS "Shards' Schema", COUNT(*) AS "Counts"
|
|
FROM information_schema.tables
|
|
WHERE table_name LIKE 'table\_set\_schema\_%' AND
|
|
table_schema IN ('old_schema', 'new_schema', 'public')
|
|
GROUP BY table_schema;
|
|
Shards' Schema | Counts
|
|
---------------------------------------------------------------------
|
|
old_schema | 4
|
|
public | 4
|
|
(2 rows)
|
|
|
|
\c - - - :master_port
|
|
SET search_path TO old_schema;
|
|
ALTER TABLE table_set_schema SET SCHEMA new_schema;
|
|
SELECT objid::oid::regnamespace as "Distributed Schemas"
|
|
FROM citus.pg_dist_object
|
|
WHERE objid::oid::regnamespace IN ('old_schema', 'new_schema');
|
|
Distributed Schemas
|
|
---------------------------------------------------------------------
|
|
old_schema
|
|
new_schema
|
|
(2 rows)
|
|
|
|
\c - - - :worker_1_port
|
|
SELECT table_schema AS "Shards' Schema", COUNT(*) AS "Counts"
|
|
FROM information_schema.tables
|
|
WHERE table_name LIKE 'table\_set\_schema\_%' AND
|
|
table_schema IN ('old_schema', 'new_schema', 'public')
|
|
GROUP BY table_schema;
|
|
Shards' Schema | Counts
|
|
---------------------------------------------------------------------
|
|
new_schema | 4
|
|
public | 4
|
|
(2 rows)
|
|
|
|
\c - - - :master_port
|
|
SELECT * FROM new_schema.table_set_schema;
|
|
id
|
|
---------------------------------------------------------------------
|
|
(0 rows)
|
|
|
|
SET search_path to public;
|
|
DROP SCHEMA old_schema CASCADE;
|
|
DROP SCHEMA new_schema CASCADE;
|
|
NOTICE: drop cascades to table new_schema.table_set_schema
|
|
DROP TABLE table_set_schema;
|
|
-- test ALTER TABLE SET SCHEMA with nonexisting schemas and table
|
|
-- expect all to give error
|
|
CREATE SCHEMA existing_schema;
|
|
CREATE SCHEMA another_existing_schema;
|
|
CREATE TABLE existing_schema.table_set_schema(id int);
|
|
SELECT create_distributed_table('existing_schema.table_set_schema', 'id');
|
|
create_distributed_table
|
|
---------------------------------------------------------------------
|
|
|
|
(1 row)
|
|
|
|
ALTER TABLE non_existent_schema.table_set_schema SET SCHEMA another_existing_schema;
|
|
ERROR: schema "non_existent_schema" does not exist
|
|
ALTER TABLE non_existent_schema.non_existent_table SET SCHEMA another_existing_schema;
|
|
ERROR: schema "non_existent_schema" does not exist
|
|
ALTER TABLE non_existent_schema.table_set_schema SET SCHEMA another_non_existent_schema;
|
|
ERROR: schema "non_existent_schema" does not exist
|
|
ALTER TABLE non_existent_schema.non_existent_table SET SCHEMA another_non_existent_schema;
|
|
ERROR: schema "non_existent_schema" does not exist
|
|
ALTER TABLE existing_schema.non_existent_table SET SCHEMA another_existing_schema;
|
|
ERROR: relation "existing_schema.non_existent_table" does not exist
|
|
ALTER TABLE existing_schema.non_existent_table SET SCHEMA non_existent_schema;
|
|
ERROR: relation "existing_schema.non_existent_table" does not exist
|
|
ALTER TABLE existing_schema.table_set_schema SET SCHEMA non_existent_schema;
|
|
ERROR: schema "non_existent_schema" does not exist
|
|
DROP SCHEMA existing_schema, another_existing_schema CASCADE;
|
|
NOTICE: drop cascades to table existing_schema.table_set_schema
|
|
-- test ALTER TABLE SET SCHEMA with interesting names
|
|
CREATE SCHEMA "cItuS.T E E N'sSchema";
|
|
CREATE SCHEMA "citus-teen's scnd schm.";
|
|
CREATE TABLE "cItuS.T E E N'sSchema"."be$t''t*ble" (id int);
|
|
SELECT create_distributed_table('"cItuS.T E E N''sSchema"."be$t''''t*ble"', 'id');
|
|
create_distributed_table
|
|
---------------------------------------------------------------------
|
|
|
|
(1 row)
|
|
|
|
ALTER TABLE "cItuS.T E E N'sSchema"."be$t''t*ble" SET SCHEMA "citus-teen's scnd schm.";
|
|
\c - - - :worker_1_port
|
|
SELECT table_schema AS "Shards' Schema"
|
|
FROM information_schema.tables
|
|
WHERE table_name LIKE 'be$t''''t*ble%'
|
|
GROUP BY table_schema;
|
|
Shards' Schema
|
|
---------------------------------------------------------------------
|
|
citus-teen's scnd schm.
|
|
(1 row)
|
|
|
|
\c - - - :master_port
|
|
SELECT * FROM "citus-teen's scnd schm."."be$t''t*ble";
|
|
id
|
|
---------------------------------------------------------------------
|
|
(0 rows)
|
|
|
|
DROP SCHEMA "cItuS.T E E N'sSchema", "citus-teen's scnd schm." CASCADE;
|
|
NOTICE: drop cascades to table "citus-teen's scnd schm."."be$t''t*ble"
|
|
-- test schema propagation with user other than current user
|
|
SELECT run_command_on_coordinator_and_workers('CREATE USER "test-user"');
|
|
NOTICE: not propagating CREATE ROLE/USER commands to worker nodes
|
|
HINT: Connect to worker nodes directly to manually create all necessary users and roles.
|
|
CONTEXT: SQL statement "CREATE USER "test-user""
|
|
PL/pgSQL function run_command_on_coordinator_and_workers(text) line 3 at EXECUTE
|
|
run_command_on_coordinator_and_workers
|
|
---------------------------------------------------------------------
|
|
|
|
(1 row)
|
|
|
|
SELECT run_command_on_coordinator_and_workers('GRANT ALL ON DATABASE postgres to "test-user"');
|
|
run_command_on_coordinator_and_workers
|
|
---------------------------------------------------------------------
|
|
|
|
(1 row)
|
|
|
|
CREATE SCHEMA schema_with_user AUTHORIZATION "test-user";
|
|
CREATE TABLE schema_with_user.test_table(column1 int);
|
|
SELECT create_reference_table('schema_with_user.test_table');
|
|
create_reference_table
|
|
---------------------------------------------------------------------
|
|
|
|
(1 row)
|
|
|
|
-- verify that owner of the created schema is test-user
|
|
\c - - - :worker_1_port
|
|
\dn schema_with_user
|
|
List of schemas
|
|
Name | Owner
|
|
---------------------------------------------------------------------
|
|
schema_with_user | test-user
|
|
(1 row)
|
|
|
|
\c - - - :master_port
|
|
-- we do not use run_command_on_coordinator_and_workers here because when there is CASCADE, it causes deadlock
|
|
DROP OWNED BY "test-user" CASCADE;
|
|
NOTICE: drop cascades to table schema_with_user.test_table
|
|
SELECT run_command_on_workers('DROP OWNED BY "test-user" CASCADE');
|
|
run_command_on_workers
|
|
---------------------------------------------------------------------
|
|
(localhost,57637,t,"DROP OWNED")
|
|
(localhost,57638,t,"DROP OWNED")
|
|
(2 rows)
|
|
|
|
SELECT run_command_on_coordinator_and_workers('DROP USER "test-user"');
|
|
run_command_on_coordinator_and_workers
|
|
---------------------------------------------------------------------
|
|
|
|
(1 row)
|
|
|
|
DROP FUNCTION run_command_on_coordinator_and_workers(p_sql text);
|
|
-- test run_command_on_* UDFs with schema
|
|
CREATE SCHEMA run_test_schema;
|
|
CREATE TABLE run_test_schema.test_table(id int);
|
|
SELECT create_distributed_table('run_test_schema.test_table','id');
|
|
create_distributed_table
|
|
---------------------------------------------------------------------
|
|
|
|
(1 row)
|
|
|
|
-- randomly insert data to evaluate below UDFs better
|
|
INSERT INTO run_test_schema.test_table VALUES(1);
|
|
INSERT INTO run_test_schema.test_table VALUES(7);
|
|
INSERT INTO run_test_schema.test_table VALUES(9);
|
|
-- try UDFs which call shard_name as a subroutine
|
|
SELECT sum(result::int) FROM run_command_on_placements('run_test_schema.test_table','SELECT pg_table_size(''%s'')');
|
|
sum
|
|
---------------------------------------------------------------------
|
|
49152
|
|
(1 row)
|
|
|
|
SELECT sum(result::int) FROM run_command_on_shards('run_test_schema.test_table','SELECT pg_table_size(''%s'')');
|
|
sum
|
|
---------------------------------------------------------------------
|
|
24576
|
|
(1 row)
|
|
|
|
-- test capital letters on both table and schema names
|
|
SET citus.task_executor_type to "adaptive";
|
|
-- create schema with weird names
|
|
CREATE SCHEMA "CiTuS.TeeN";
|
|
CREATE SCHEMA "CiTUS.TEEN2";
|
|
-- create table with weird names
|
|
CREATE TABLE "CiTuS.TeeN"."TeeNTabLE.1!?!"(id int, "TeNANt_Id" int);
|
|
CREATE TABLE "CiTUS.TEEN2"."CAPITAL_TABLE"(i int, j int);
|
|
-- create distributed table with weird names
|
|
SELECT create_distributed_table('"CiTuS.TeeN"."TeeNTabLE.1!?!"', 'TeNANt_Id');
|
|
create_distributed_table
|
|
---------------------------------------------------------------------
|
|
|
|
(1 row)
|
|
|
|
SELECT create_distributed_table('"CiTUS.TEEN2"."CAPITAL_TABLE"', 'i');
|
|
create_distributed_table
|
|
---------------------------------------------------------------------
|
|
|
|
(1 row)
|
|
|
|
-- truncate tables with weird names
|
|
INSERT INTO "CiTuS.TeeN"."TeeNTabLE.1!?!" VALUES(1, 1);
|
|
INSERT INTO "CiTUS.TEEN2"."CAPITAL_TABLE" VALUES(0, 1);
|
|
TRUNCATE "CiTuS.TeeN"."TeeNTabLE.1!?!", "CiTUS.TEEN2"."CAPITAL_TABLE";
|
|
SELECT count(*) FROM "CiTUS.TEEN2"."CAPITAL_TABLE";
|
|
count
|
|
---------------------------------------------------------------------
|
|
0
|
|
(1 row)
|
|
|
|
-- insert into table with weird names
|
|
INSERT INTO "CiTuS.TeeN"."TeeNTabLE.1!?!" VALUES(1, 1),(1, 0),(0, 1),(2, 3),(3, 2),(4, 4);
|
|
INSERT INTO "CiTUS.TEEN2"."CAPITAL_TABLE" VALUES(0, 1),(1, 0),(2, 1),(4, 3),(3, 2),(4, 4);
|
|
-- join on tables with weird names
|
|
SELECT *
|
|
FROM "CiTuS.TeeN"."TeeNTabLE.1!?!", "CiTUS.TEEN2"."CAPITAL_TABLE"
|
|
WHERE "CiTUS.TEEN2"."CAPITAL_TABLE".i = "CiTuS.TeeN"."TeeNTabLE.1!?!"."TeNANt_Id"
|
|
ORDER BY 1,2,3,4;
|
|
id | TeNANt_Id | i | j
|
|
---------------------------------------------------------------------
|
|
0 | 1 | 1 | 0
|
|
1 | 0 | 0 | 1
|
|
1 | 1 | 1 | 0
|
|
2 | 3 | 3 | 2
|
|
3 | 2 | 2 | 1
|
|
4 | 4 | 4 | 3
|
|
4 | 4 | 4 | 4
|
|
(7 rows)
|
|
|
|
-- add group by, having, order by clauses
|
|
SELECT *
|
|
FROM "CiTuS.TeeN"."TeeNTabLE.1!?!", "CiTUS.TEEN2"."CAPITAL_TABLE"
|
|
WHERE "CiTUS.TEEN2"."CAPITAL_TABLE".i = "CiTuS.TeeN"."TeeNTabLE.1!?!"."TeNANt_Id"
|
|
GROUP BY "TeNANt_Id", id, i, j
|
|
HAVING "TeNANt_Id" > 0 AND j >= id ORDER BY "TeNANt_Id";
|
|
id | TeNANt_Id | i | j
|
|
---------------------------------------------------------------------
|
|
0 | 1 | 1 | 0
|
|
2 | 3 | 3 | 2
|
|
4 | 4 | 4 | 4
|
|
(3 rows)
|
|
|
|
SELECT *
|
|
FROM "CiTuS.TeeN"."TeeNTabLE.1!?!" join "CiTUS.TEEN2"."CAPITAL_TABLE" on
|
|
("CiTUS.TEEN2"."CAPITAL_TABLE".i = "CiTuS.TeeN"."TeeNTabLE.1!?!"."TeNANt_Id")
|
|
GROUP BY "TeNANt_Id", id, i, j
|
|
HAVING "TeNANt_Id" > 0 AND j >= id
|
|
ORDER BY 1,2,3,4;
|
|
id | TeNANt_Id | i | j
|
|
---------------------------------------------------------------------
|
|
0 | 1 | 1 | 0
|
|
2 | 3 | 3 | 2
|
|
4 | 4 | 4 | 4
|
|
(3 rows)
|
|
|
|
-- run with CTEs
|
|
WITH "cTE" AS (
|
|
SELECT *
|
|
FROM "CiTuS.TeeN"."TeeNTabLE.1!?!"
|
|
)
|
|
SELECT * FROM "cTE" join "CiTUS.TEEN2"."CAPITAL_TABLE" on
|
|
("cTE"."TeNANt_Id" = "CiTUS.TEEN2"."CAPITAL_TABLE".i)
|
|
GROUP BY "TeNANt_Id", id, i, j
|
|
HAVING "TeNANt_Id" > 0 AND j >= id
|
|
ORDER BY 1,2,3,4;
|
|
id | TeNANt_Id | i | j
|
|
---------------------------------------------------------------------
|
|
0 | 1 | 1 | 0
|
|
2 | 3 | 3 | 2
|
|
4 | 4 | 4 | 4
|
|
(3 rows)
|
|
|
|
SET search_path to "CiTuS.TeeN";
|
|
-- and subqueries
|
|
SELECT *
|
|
FROM (
|
|
SELECT *
|
|
FROM "TeeNTabLE.1!?!"
|
|
) "cTE"
|
|
join "CiTUS.TEEN2"."CAPITAL_TABLE" on
|
|
("cTE"."TeNANt_Id" = "CiTUS.TEEN2"."CAPITAL_TABLE".i)
|
|
GROUP BY "TeNANt_Id", id, i, j
|
|
HAVING "TeNANt_Id" > 0 AND j >= id
|
|
ORDER BY 1,2,3,4;
|
|
id | TeNANt_Id | i | j
|
|
---------------------------------------------------------------------
|
|
0 | 1 | 1 | 0
|
|
2 | 3 | 3 | 2
|
|
4 | 4 | 4 | 4
|
|
(3 rows)
|
|
|
|
SET search_path to default;
|
|
-- Some DDL
|
|
ALTER TABLE "CiTuS.TeeN"."TeeNTabLE.1!?!" ADD COLUMN "NEW_TeeN:COl" text;
|
|
-- Some DML
|
|
DELETE FROM "CiTuS.TeeN"."TeeNTabLE.1!?!" WHERE "TeNANt_Id"=1;
|
|
-- Some more DDL
|
|
ALTER TABLE "CiTuS.TeeN"."TeeNTabLE.1!?!" ADD CONSTRAINT "ConsNAmE<>" PRIMARY KEY ("TeNANt_Id");
|
|
-- Clean up the created schema
|
|
DROP SCHEMA run_test_schema CASCADE;
|
|
NOTICE: drop cascades to table run_test_schema.test_table
|
|
DROP SCHEMA test_schema_support_join_1 CASCADE;
|
|
NOTICE: drop cascades to 2 other objects
|
|
DETAIL: drop cascades to table test_schema_support_join_1.nation_hash
|
|
drop cascades to table test_schema_support_join_1.nation_hash_2
|
|
DROP SCHEMA test_schema_support_join_2 CASCADE;
|
|
NOTICE: drop cascades to table test_schema_support_join_2.nation_hash
|
|
DROP SCHEMA "CiTuS.TeeN" CASCADE;
|
|
NOTICE: drop cascades to table "CiTuS.TeeN"."TeeNTabLE.1!?!"
|
|
DROP SCHEMA "CiTUS.TEEN2" CASCADE;
|
|
NOTICE: drop cascades to table "CiTUS.TEEN2"."CAPITAL_TABLE"
|