mirror of https://github.com/citusdata/citus.git
731 lines
38 KiB
Plaintext
731 lines
38 KiB
Plaintext
--
|
|
-- MULTI_INDEX_STATEMENTS
|
|
--
|
|
-- Check that we can run CREATE INDEX and DROP INDEX statements on distributed
|
|
-- tables.
|
|
--
|
|
-- CREATE TEST TABLES
|
|
--
|
|
CREATE SCHEMA multi_index_statements;
|
|
CREATE SCHEMA multi_index_statements_2;
|
|
SET search_path TO multi_index_statements;
|
|
SET citus.next_shard_id TO 102080;
|
|
CREATE TABLE index_test_range(a int, b int, c int);
|
|
SELECT create_distributed_table('index_test_range', 'a', 'range');
|
|
create_distributed_table
|
|
---------------------------------------------------------------------
|
|
|
|
(1 row)
|
|
|
|
SELECT master_create_empty_shard('index_test_range');
|
|
master_create_empty_shard
|
|
---------------------------------------------------------------------
|
|
102080
|
|
(1 row)
|
|
|
|
SELECT master_create_empty_shard('index_test_range');
|
|
master_create_empty_shard
|
|
---------------------------------------------------------------------
|
|
102081
|
|
(1 row)
|
|
|
|
SET citus.shard_count TO 8;
|
|
SET citus.shard_replication_factor TO 2;
|
|
CREATE TABLE index_test_hash(a int, b int, c int, a_text text, b_text text);
|
|
SELECT create_distributed_table('index_test_hash', 'a', 'hash');
|
|
create_distributed_table
|
|
---------------------------------------------------------------------
|
|
|
|
(1 row)
|
|
|
|
CREATE TABLE index_test_append(a int, b int, c int);
|
|
SELECT create_distributed_table('index_test_append', 'a', 'append');
|
|
create_distributed_table
|
|
---------------------------------------------------------------------
|
|
|
|
(1 row)
|
|
|
|
SELECT master_create_empty_shard('index_test_append');
|
|
master_create_empty_shard
|
|
---------------------------------------------------------------------
|
|
102090
|
|
(1 row)
|
|
|
|
SELECT master_create_empty_shard('index_test_append');
|
|
master_create_empty_shard
|
|
---------------------------------------------------------------------
|
|
102091
|
|
(1 row)
|
|
|
|
--
|
|
-- CREATE INDEX
|
|
--
|
|
-- Verify that we can create different types of indexes
|
|
CREATE INDEX lineitem_orderkey_index ON public.lineitem (l_orderkey);
|
|
CREATE INDEX lineitem_partkey_desc_index ON public.lineitem (l_partkey DESC);
|
|
CREATE INDEX lineitem_partial_index ON public.lineitem (l_shipdate)
|
|
WHERE l_shipdate < '1995-01-01';
|
|
CREATE INDEX lineitem_colref_index ON public.lineitem (record_ne(lineitem.*, NULL));
|
|
SET client_min_messages = ERROR; -- avoid version dependent warning about WAL
|
|
CREATE INDEX lineitem_orderkey_hash_index ON public.lineitem USING hash (l_partkey);
|
|
CREATE UNIQUE INDEX index_test_range_index_a ON index_test_range(a);
|
|
CREATE UNIQUE INDEX index_test_range_index_a_b ON index_test_range(a,b);
|
|
CREATE UNIQUE INDEX index_test_hash_index_a ON index_test_hash(a);
|
|
CREATE UNIQUE INDEX index_test_hash_index_a_b ON index_test_hash(a,b);
|
|
CREATE UNIQUE INDEX index_test_hash_index_a_b_partial ON index_test_hash(a,b) WHERE c IS NOT NULL;
|
|
CREATE UNIQUE INDEX index_test_range_index_a_b_partial ON index_test_range(a,b) WHERE c IS NOT NULL;
|
|
CREATE UNIQUE INDEX index_test_hash_index_a_b_c ON index_test_hash(a) INCLUDE (b,c);
|
|
RESET client_min_messages;
|
|
-- Verify that we can create expression indexes and be robust to different schemas
|
|
CREATE OR REPLACE FUNCTION value_plus_one(a int)
|
|
RETURNS int IMMUTABLE AS $$
|
|
BEGIN
|
|
RETURN a + 1;
|
|
END;
|
|
$$ LANGUAGE plpgsql;
|
|
SELECT create_distributed_function('value_plus_one(int)');
|
|
NOTICE: procedure multi_index_statements.value_plus_one is already distributed
|
|
DETAIL: Citus distributes procedures with CREATE [PROCEDURE|FUNCTION|AGGREGATE] commands
|
|
create_distributed_function
|
|
---------------------------------------------------------------------
|
|
|
|
(1 row)
|
|
|
|
CREATE OR REPLACE FUNCTION multi_index_statements_2.value_plus_one(a int)
|
|
RETURNS int IMMUTABLE AS $$
|
|
BEGIN
|
|
RETURN a + 1;
|
|
END;
|
|
$$ LANGUAGE plpgsql;
|
|
SELECT create_distributed_function('multi_index_statements_2.value_plus_one(int)');
|
|
NOTICE: procedure multi_index_statements_2.value_plus_one is already distributed
|
|
DETAIL: Citus distributes procedures with CREATE [PROCEDURE|FUNCTION|AGGREGATE] commands
|
|
create_distributed_function
|
|
---------------------------------------------------------------------
|
|
|
|
(1 row)
|
|
|
|
CREATE FUNCTION predicate_stable() RETURNS bool IMMUTABLE
|
|
LANGUAGE plpgsql AS $$
|
|
BEGIN
|
|
EXECUTE 'SELECT txid_current()';
|
|
RETURN true;
|
|
END; $$;
|
|
CREATE INDEX ON index_test_hash ((value_plus_one(b)));
|
|
CREATE INDEX ON index_test_hash ((value_plus_one(b) + value_plus_one(c))) WHERE value_plus_one(c) > 10;
|
|
CREATE INDEX ON index_test_hash (a) WHERE value_plus_one(c) > 10;
|
|
CREATE INDEX ON index_test_hash (abs(a)) WHERE value_plus_one(c) > 10;
|
|
CREATE INDEX ON index_test_hash (value_plus_one(a)) WHERE c > 10;
|
|
CREATE INDEX ON index_test_hash ((multi_index_statements.value_plus_one(b)));
|
|
CREATE INDEX ON index_test_hash ((multi_index_statements_2.value_plus_one(b)));
|
|
CREATE INDEX ON index_test_hash (a) INCLUDE (b) WHERE value_plus_one(c) > 10;
|
|
CREATE INDEX ON index_test_hash (c, (c+0)) INCLUDE (a);
|
|
CREATE INDEX ON index_test_hash (value_plus_one(a)) INCLUDE (c,b) WHERE value_plus_one(c) > 10;
|
|
CREATE INDEX ON index_test_hash ((a_text || b_text));
|
|
CREATE INDEX ON index_test_hash ((a_text || b_text)) WHERE value_plus_one(c) > 10;
|
|
CREATE INDEX ON index_test_hash ((a_text || b_text)) WHERE (a_text || b_text) = 'ttt';
|
|
CREATE INDEX CONCURRENTLY ON index_test_hash (a) WHERE predicate_stable();
|
|
-- Verify that we handle if not exists statements correctly
|
|
CREATE INDEX lineitem_orderkey_index on public.lineitem(l_orderkey);
|
|
ERROR: relation "lineitem_orderkey_index" already exists
|
|
CREATE INDEX IF NOT EXISTS lineitem_orderkey_index on public.lineitem(l_orderkey);
|
|
NOTICE: relation "lineitem_orderkey_index" already exists, skipping
|
|
CREATE INDEX IF NOT EXISTS lineitem_orderkey_index_new on public.lineitem(l_orderkey);
|
|
-- Verify if not exists behavior with an index with same name on a different table
|
|
CREATE INDEX lineitem_orderkey_index on public.nation(n_nationkey);
|
|
ERROR: relation "lineitem_orderkey_index" already exists
|
|
CREATE INDEX IF NOT EXISTS lineitem_orderkey_index on public.nation(n_nationkey);
|
|
NOTICE: relation "lineitem_orderkey_index" already exists, skipping
|
|
-- Verify that we can create indexes concurrently
|
|
CREATE INDEX CONCURRENTLY lineitem_concurrently_index ON public.lineitem (l_orderkey);
|
|
-- Verify that no-name local CREATE INDEX CONCURRENTLY works
|
|
CREATE TABLE local_table (id integer, name text);
|
|
CREATE INDEX CONCURRENTLY ON local_table(id);
|
|
-- Vefify we don't warn out on CLUSTER command for local tables
|
|
CREATE INDEX CONCURRENTLY local_table_index ON local_table(id);
|
|
CLUSTER local_table USING local_table_index;
|
|
DROP TABLE local_table;
|
|
-- Verify that we can run CLUSTER command
|
|
CLUSTER index_test_hash USING index_test_hash_index_a;
|
|
-- Verify that we ERROR on CLUSTER VERBOSE
|
|
CLUSTER VERBOSE index_test_hash USING index_test_hash_index_a;
|
|
ERROR: cannot run CLUSTER command
|
|
DETAIL: VERBOSE option is currently unsupported for distributed tables.
|
|
-- Verify that we WARN on CLUSTER ALL
|
|
CLUSTER;
|
|
WARNING: not propagating CLUSTER command to worker nodes
|
|
HINT: Provide a specific table in order to CLUSTER distributed tables.
|
|
-- Verify that all indexes got created on the master node and one of the workers
|
|
SELECT * FROM pg_indexes WHERE tablename = 'lineitem' or tablename like 'index_test_%' ORDER BY indexname;
|
|
schemaname | tablename | indexname | tablespace | indexdef
|
|
---------------------------------------------------------------------
|
|
multi_index_statements | index_test_hash | index_test_hash_a_b_idx | | CREATE INDEX index_test_hash_a_b_idx ON multi_index_statements.index_test_hash USING btree (a) INCLUDE (b) WHERE (value_plus_one(c) > 10)
|
|
multi_index_statements | index_test_hash | index_test_hash_a_idx | | CREATE INDEX index_test_hash_a_idx ON multi_index_statements.index_test_hash USING btree (a) WHERE (value_plus_one(c) > 10)
|
|
multi_index_statements | index_test_hash | index_test_hash_a_idx1 | | CREATE INDEX index_test_hash_a_idx1 ON multi_index_statements.index_test_hash USING btree (a) WHERE predicate_stable()
|
|
multi_index_statements | index_test_hash | index_test_hash_abs_idx | | CREATE INDEX index_test_hash_abs_idx ON multi_index_statements.index_test_hash USING btree (abs(a)) WHERE (value_plus_one(c) > 10)
|
|
multi_index_statements | index_test_hash | index_test_hash_c_expr_a_idx | | CREATE INDEX index_test_hash_c_expr_a_idx ON multi_index_statements.index_test_hash USING btree (c, ((c + 0))) INCLUDE (a)
|
|
multi_index_statements | index_test_hash | index_test_hash_expr_idx | | CREATE INDEX index_test_hash_expr_idx ON multi_index_statements.index_test_hash USING btree (((value_plus_one(b) + value_plus_one(c)))) WHERE (value_plus_one(c) > 10)
|
|
multi_index_statements | index_test_hash | index_test_hash_expr_idx1 | | CREATE INDEX index_test_hash_expr_idx1 ON multi_index_statements.index_test_hash USING btree (((a_text || b_text)))
|
|
multi_index_statements | index_test_hash | index_test_hash_expr_idx2 | | CREATE INDEX index_test_hash_expr_idx2 ON multi_index_statements.index_test_hash USING btree (((a_text || b_text))) WHERE (value_plus_one(c) > 10)
|
|
multi_index_statements | index_test_hash | index_test_hash_expr_idx3 | | CREATE INDEX index_test_hash_expr_idx3 ON multi_index_statements.index_test_hash USING btree (((a_text || b_text))) WHERE ((a_text || b_text) = 'ttt'::text)
|
|
multi_index_statements | index_test_hash | index_test_hash_index_a | | CREATE UNIQUE INDEX index_test_hash_index_a ON multi_index_statements.index_test_hash USING btree (a)
|
|
multi_index_statements | index_test_hash | index_test_hash_index_a_b | | CREATE UNIQUE INDEX index_test_hash_index_a_b ON multi_index_statements.index_test_hash USING btree (a, b)
|
|
multi_index_statements | index_test_hash | index_test_hash_index_a_b_c | | CREATE UNIQUE INDEX index_test_hash_index_a_b_c ON multi_index_statements.index_test_hash USING btree (a) INCLUDE (b, c)
|
|
multi_index_statements | index_test_hash | index_test_hash_index_a_b_partial | | CREATE UNIQUE INDEX index_test_hash_index_a_b_partial ON multi_index_statements.index_test_hash USING btree (a, b) WHERE (c IS NOT NULL)
|
|
multi_index_statements | index_test_hash | index_test_hash_value_plus_one_c_b_idx | | CREATE INDEX index_test_hash_value_plus_one_c_b_idx ON multi_index_statements.index_test_hash USING btree (value_plus_one(a)) INCLUDE (c, b) WHERE (value_plus_one(c) > 10)
|
|
multi_index_statements | index_test_hash | index_test_hash_value_plus_one_idx | | CREATE INDEX index_test_hash_value_plus_one_idx ON multi_index_statements.index_test_hash USING btree (value_plus_one(b))
|
|
multi_index_statements | index_test_hash | index_test_hash_value_plus_one_idx1 | | CREATE INDEX index_test_hash_value_plus_one_idx1 ON multi_index_statements.index_test_hash USING btree (value_plus_one(a)) WHERE (c > 10)
|
|
multi_index_statements | index_test_hash | index_test_hash_value_plus_one_idx2 | | CREATE INDEX index_test_hash_value_plus_one_idx2 ON multi_index_statements.index_test_hash USING btree (value_plus_one(b))
|
|
multi_index_statements | index_test_hash | index_test_hash_value_plus_one_idx3 | | CREATE INDEX index_test_hash_value_plus_one_idx3 ON multi_index_statements.index_test_hash USING btree (multi_index_statements_2.value_plus_one(b))
|
|
multi_index_statements | index_test_range | index_test_range_index_a | | CREATE UNIQUE INDEX index_test_range_index_a ON multi_index_statements.index_test_range USING btree (a)
|
|
multi_index_statements | index_test_range | index_test_range_index_a_b | | CREATE UNIQUE INDEX index_test_range_index_a_b ON multi_index_statements.index_test_range USING btree (a, b)
|
|
multi_index_statements | index_test_range | index_test_range_index_a_b_partial | | CREATE UNIQUE INDEX index_test_range_index_a_b_partial ON multi_index_statements.index_test_range USING btree (a, b) WHERE (c IS NOT NULL)
|
|
public | lineitem | lineitem_colref_index | | CREATE INDEX lineitem_colref_index ON public.lineitem USING btree (record_ne(lineitem.*, NULL::record))
|
|
public | lineitem | lineitem_concurrently_index | | CREATE INDEX lineitem_concurrently_index ON public.lineitem USING btree (l_orderkey)
|
|
public | lineitem | lineitem_orderkey_hash_index | | CREATE INDEX lineitem_orderkey_hash_index ON public.lineitem USING hash (l_partkey)
|
|
public | lineitem | lineitem_orderkey_index | | CREATE INDEX lineitem_orderkey_index ON public.lineitem USING btree (l_orderkey)
|
|
public | lineitem | lineitem_orderkey_index_new | | CREATE INDEX lineitem_orderkey_index_new ON public.lineitem USING btree (l_orderkey)
|
|
public | lineitem | lineitem_partial_index | | CREATE INDEX lineitem_partial_index ON public.lineitem USING btree (l_shipdate) WHERE (l_shipdate < '01-01-1995'::date)
|
|
public | lineitem | lineitem_partkey_desc_index | | CREATE INDEX lineitem_partkey_desc_index ON public.lineitem USING btree (l_partkey DESC)
|
|
public | lineitem | lineitem_pkey | | CREATE UNIQUE INDEX lineitem_pkey ON public.lineitem USING btree (l_orderkey, l_linenumber)
|
|
public | lineitem | lineitem_time_index | | CREATE INDEX lineitem_time_index ON public.lineitem USING btree (l_shipdate)
|
|
(30 rows)
|
|
|
|
\c - - - :worker_1_port
|
|
SELECT count(*) FROM pg_indexes WHERE tablename = (SELECT relname FROM pg_class WHERE relname LIKE 'lineitem_%' ORDER BY relname LIMIT 1);
|
|
count
|
|
---------------------------------------------------------------------
|
|
9
|
|
(1 row)
|
|
|
|
SELECT count(*) FROM pg_indexes WHERE tablename LIKE 'index_test_hash_%';
|
|
count
|
|
---------------------------------------------------------------------
|
|
144
|
|
(1 row)
|
|
|
|
SELECT count(*) FROM pg_indexes WHERE tablename LIKE 'index_test_range_%';
|
|
count
|
|
---------------------------------------------------------------------
|
|
6
|
|
(1 row)
|
|
|
|
SELECT count(*) FROM pg_indexes WHERE tablename LIKE 'index_test_append_%';
|
|
count
|
|
---------------------------------------------------------------------
|
|
0
|
|
(1 row)
|
|
|
|
-- Verify that we actually run the CLUSTER COMMAND
|
|
SELECT sum(indisclustered::integer) FROM pg_index WHERE indrelid::regclass::text SIMILAR TO '%\d';
|
|
sum
|
|
---------------------------------------------------------------------
|
|
8
|
|
(1 row)
|
|
|
|
\c - - - :master_port
|
|
SET search_path TO multi_index_statements, public;
|
|
-- Verify that we error out on unsupported statement types
|
|
CREATE INDEX try_index ON lineitem (l_orderkey) TABLESPACE newtablespace;
|
|
ERROR: specifying tablespaces with CREATE INDEX statements is currently unsupported
|
|
CREATE UNIQUE INDEX try_unique_range_index ON index_test_range(b);
|
|
ERROR: creating unique indexes on non-partition columns is currently unsupported
|
|
CREATE UNIQUE INDEX try_unique_range_index_partial ON index_test_range(b) WHERE c IS NOT NULL;
|
|
ERROR: creating unique indexes on non-partition columns is currently unsupported
|
|
CREATE UNIQUE INDEX try_unique_hash_index ON index_test_hash(b);
|
|
ERROR: creating unique indexes on non-partition columns is currently unsupported
|
|
CREATE UNIQUE INDEX try_unique_hash_index_partial ON index_test_hash(b) WHERE c IS NOT NULL;
|
|
ERROR: creating unique indexes on non-partition columns is currently unsupported
|
|
CREATE UNIQUE INDEX try_unique_append_index ON index_test_append(b);
|
|
ERROR: creating unique indexes on append-partitioned tables is currently unsupported
|
|
CREATE UNIQUE INDEX try_unique_append_index ON index_test_append(a);
|
|
ERROR: creating unique indexes on append-partitioned tables is currently unsupported
|
|
CREATE UNIQUE INDEX try_unique_append_index_a_b ON index_test_append(a,b);
|
|
ERROR: creating unique indexes on append-partitioned tables is currently unsupported
|
|
-- Verify that we error out in case of postgres errors on supported statement
|
|
-- types.
|
|
CREATE INDEX lineitem_orderkey_index ON lineitem (l_orderkey);
|
|
ERROR: relation "lineitem_orderkey_index" already exists
|
|
CREATE INDEX try_index ON lineitem USING gist (l_orderkey);
|
|
ERROR: data type bigint has no default operator class for access method "gist"
|
|
HINT: You must specify an operator class for the index or define a default operator class for the data type.
|
|
CREATE INDEX try_index ON lineitem (non_existent_column);
|
|
ERROR: column "non_existent_column" does not exist
|
|
-- show that we support indexes without names
|
|
CREATE INDEX ON lineitem (l_orderkey);
|
|
CREATE UNIQUE INDEX ON index_test_hash(a);
|
|
CREATE INDEX CONCURRENTLY ON lineitem USING hash (l_shipdate);
|
|
--
|
|
-- REINDEX
|
|
--
|
|
REINDEX INDEX lineitem_orderkey_index;
|
|
REINDEX TABLE lineitem;
|
|
REINDEX SCHEMA public;
|
|
REINDEX DATABASE regression;
|
|
REINDEX SYSTEM regression;
|
|
--
|
|
-- DROP INDEX
|
|
--
|
|
-- Verify that we can't drop multiple indexes in a single command
|
|
DROP INDEX lineitem_orderkey_index, lineitem_partial_index;
|
|
ERROR: cannot drop multiple distributed objects in a single command
|
|
HINT: Try dropping each object in a separate DROP command.
|
|
-- Verify that we can succesfully drop indexes
|
|
DROP INDEX lineitem_orderkey_index;
|
|
DROP INDEX lineitem_orderkey_index_new;
|
|
DROP INDEX lineitem_partkey_desc_index;
|
|
DROP INDEX lineitem_partial_index;
|
|
DROP INDEX lineitem_colref_index;
|
|
-- Verify that we handle if exists statements correctly
|
|
DROP INDEX non_existent_index;
|
|
ERROR: index "non_existent_index" does not exist
|
|
DROP INDEX IF EXISTS non_existent_index;
|
|
NOTICE: index "non_existent_index" does not exist, skipping
|
|
DROP INDEX IF EXISTS lineitem_orderkey_hash_index;
|
|
DROP INDEX lineitem_orderkey_hash_index;
|
|
ERROR: index "lineitem_orderkey_hash_index" does not exist
|
|
DROP INDEX index_test_range_index_a;
|
|
DROP INDEX index_test_range_index_a_b;
|
|
DROP INDEX index_test_range_index_a_b_partial;
|
|
DROP INDEX index_test_hash_index_a;
|
|
DROP INDEX index_test_hash_index_a_b;
|
|
DROP INDEX index_test_hash_index_a_b_partial;
|
|
-- Verify that we can drop indexes concurrently
|
|
DROP INDEX CONCURRENTLY lineitem_concurrently_index;
|
|
-- Verify that all indexes got created on the coordinator node and on the workers
|
|
-- by dropping the indexes. We do this because in different PG versions,
|
|
-- the expression indexes are named differently
|
|
-- and, being able to drop the index ensures that the index names are
|
|
-- proper
|
|
CREATE OR REPLACE FUNCTION drop_all_indexes(table_name regclass) RETURNS INTEGER AS $$
|
|
DECLARE
|
|
i RECORD;
|
|
BEGIN
|
|
FOR i IN
|
|
(SELECT indexrelid::regclass::text as relname FROM pg_index
|
|
WHERE indrelid = table_name and indexrelid::regclass::text not ilike '%pkey%')
|
|
LOOP
|
|
EXECUTE 'DROP INDEX ' || i.relname;
|
|
END LOOP;
|
|
RETURN 1;
|
|
END;
|
|
$$ LANGUAGE plpgsql;
|
|
SELECT drop_all_indexes('public.lineitem');
|
|
drop_all_indexes
|
|
---------------------------------------------------------------------
|
|
1
|
|
(1 row)
|
|
|
|
SELECT drop_all_indexes('index_test_range');
|
|
drop_all_indexes
|
|
---------------------------------------------------------------------
|
|
1
|
|
(1 row)
|
|
|
|
SELECT drop_all_indexes('index_test_hash');
|
|
drop_all_indexes
|
|
---------------------------------------------------------------------
|
|
1
|
|
(1 row)
|
|
|
|
SELECT drop_all_indexes('index_test_append');
|
|
drop_all_indexes
|
|
---------------------------------------------------------------------
|
|
1
|
|
(1 row)
|
|
|
|
-- Verify that all the indexes are dropped from the master and one worker node.
|
|
-- As there's a primary key, so exclude those from this check.
|
|
SELECT indrelid::regclass, indexrelid::regclass FROM pg_index WHERE indrelid = (SELECT relname FROM pg_class WHERE relname LIKE 'lineitem%' ORDER BY relname LIMIT 1)::regclass AND NOT indisprimary AND indexrelid::regclass::text NOT LIKE 'lineitem_time_index%' ORDER BY 1,2;
|
|
indrelid | indexrelid
|
|
---------------------------------------------------------------------
|
|
(0 rows)
|
|
|
|
SELECT * FROM pg_indexes WHERE tablename LIKE 'index_test_%' ORDER BY indexname;
|
|
schemaname | tablename | indexname | tablespace | indexdef
|
|
---------------------------------------------------------------------
|
|
(0 rows)
|
|
|
|
\c - - - :worker_1_port
|
|
SET citus.override_table_visibility TO FALSE;
|
|
SELECT indrelid::regclass, indexrelid::regclass FROM pg_index WHERE indrelid = (SELECT relname FROM pg_class WHERE relname SIMILAR TO 'lineitem%\d' ORDER BY relname LIMIT 1)::regclass AND NOT indisprimary AND indexrelid::regclass::text NOT LIKE 'lineitem_time_index%' ORDER BY 1,2;
|
|
indrelid | indexrelid
|
|
---------------------------------------------------------------------
|
|
(0 rows)
|
|
|
|
SELECT * FROM pg_indexes WHERE tablename SIMILAR TO 'index_test_%\d' ORDER BY indexname;
|
|
schemaname | tablename | indexname | tablespace | indexdef
|
|
---------------------------------------------------------------------
|
|
(0 rows)
|
|
|
|
-- create index that will conflict with master operations
|
|
CREATE INDEX CONCURRENTLY ith_b_idx_102089 ON multi_index_statements.index_test_hash_102089(b);
|
|
\c - - - :master_port
|
|
SET search_path TO multi_index_statements;
|
|
-- should fail because worker index already exists
|
|
CREATE INDEX CONCURRENTLY ith_b_idx ON index_test_hash(b);
|
|
ERROR: CONCURRENTLY-enabled index command failed
|
|
DETAIL: CONCURRENTLY-enabled index commands can fail partially, leaving behind an INVALID index.
|
|
HINT: Use DROP INDEX CONCURRENTLY IF EXISTS to remove the invalid index, then retry the original command.
|
|
-- the failure results in an INVALID index
|
|
SELECT indisvalid AS "Index Valid?" FROM pg_index WHERE indexrelid='ith_b_idx'::regclass;
|
|
Index Valid?
|
|
---------------------------------------------------------------------
|
|
f
|
|
(1 row)
|
|
|
|
-- we can clean it up and recreate with an DROP IF EXISTS
|
|
DROP INDEX CONCURRENTLY IF EXISTS ith_b_idx;
|
|
CREATE INDEX CONCURRENTLY ith_b_idx ON index_test_hash(b);
|
|
SELECT indisvalid AS "Index Valid?" FROM pg_index WHERE indexrelid='ith_b_idx'::regclass;
|
|
Index Valid?
|
|
---------------------------------------------------------------------
|
|
t
|
|
(1 row)
|
|
|
|
\c - - - :worker_1_port
|
|
SET search_path TO multi_index_statements;
|
|
-- now drop shard index to test partial master DROP failure
|
|
DROP INDEX CONCURRENTLY ith_b_idx_102089;
|
|
\c - - - :master_port
|
|
SET search_path TO multi_index_statements;
|
|
SET citus.next_shard_id TO 103080;
|
|
SET citus.shard_count TO 32;
|
|
SET citus.shard_replication_factor TO 1;
|
|
-- the following tests are intended to show that
|
|
-- Citus does not get into self-deadlocks because
|
|
-- of long index names. So, make sure that we have
|
|
-- enough remote connections to trigger the case
|
|
SET citus.force_max_query_parallelization TO ON;
|
|
CREATE TABLE test_index_creation1
|
|
(
|
|
tenant_id integer NOT NULL,
|
|
timeperiod timestamp without time zone NOT NULL,
|
|
field1 integer NOT NULL,
|
|
inserted_utc timestamp without time zone NOT NULL DEFAULT now(),
|
|
PRIMARY KEY(tenant_id, timeperiod)
|
|
) PARTITION BY RANGE (timeperiod);
|
|
select create_distributed_table('test_index_creation1', 'tenant_id');
|
|
create_distributed_table
|
|
---------------------------------------------------------------------
|
|
|
|
(1 row)
|
|
|
|
-- should be able to create short named indexes in parallel
|
|
-- as there are no partitions even if the index name is too long
|
|
SET client_min_messages TO DEBUG1;
|
|
CREATE INDEX ix_test_index_creation1_ix_test_index_creation1_ix_test_index_creation1_ix_test_index_creation1_ix_test_index_creation1
|
|
ON test_index_creation1 USING btree
|
|
(tenant_id, timeperiod);
|
|
NOTICE: identifier "ix_test_index_creation1_ix_test_index_creation1_ix_test_index_creation1_ix_test_index_creation1_ix_test_index_creation1" will be truncated to "ix_test_index_creation1_ix_test_index_creation1_ix_test_index_c"
|
|
DEBUG: identifier "ix_test_index_creation1_ix_test_index_creation1_ix_test_index_creation1_ix_test_index_creation1_ix_test_index_creation1" will be truncated to "ix_test_index_creation1_ix_test_index_creation1_ix_test_index_c"
|
|
DETAIL: from localhost:xxxxx
|
|
DEBUG: identifier "ix_test_index_creation1_ix_test_index_creation1_ix_test_index_creation1_ix_test_index_creation1_ix_test_index_creation1" will be truncated to "ix_test_index_creation1_ix_test_index_creation1_ix_test_index_c"
|
|
DETAIL: from localhost:xxxxx
|
|
RESET client_min_messages;
|
|
CREATE TABLE test_index_creation1_p2020_09_26 PARTITION OF test_index_creation1 FOR VALUES FROM ('2020-09-26 00:00:00') TO ('2020-09-27 00:00:00');
|
|
CREATE TABLE test_index_creation1_p2020_09_27 PARTITION OF test_index_creation1 FOR VALUES FROM ('2020-09-27 00:00:00') TO ('2020-09-28 00:00:00');
|
|
-- should switch to sequential execution as the index name on the partition is
|
|
-- longer than 63
|
|
SET client_min_messages TO DEBUG1;
|
|
CREATE INDEX ix_test_index_creation2
|
|
ON test_index_creation1 USING btree
|
|
(tenant_id, timeperiod);
|
|
DEBUG: the index name on the shards of the partition is too long, switching to sequential and local execution mode to prevent self deadlocks: test_index_creation1_p2020_09_26_xxxxxx_tenant_id_timeperiod_idx
|
|
-- same test with schema qualified
|
|
SET search_path TO public;
|
|
CREATE INDEX ix_test_index_creation3
|
|
ON multi_index_statements.test_index_creation1 USING btree
|
|
(tenant_id, timeperiod);
|
|
DEBUG: the index name on the shards of the partition is too long, switching to sequential and local execution mode to prevent self deadlocks: test_index_creation1_p2020_09_26_xxxxxx_tenant_id_timeperiod_idx
|
|
SET search_path TO multi_index_statements;
|
|
-- we cannot switch to sequential execution
|
|
-- after a parallel query
|
|
BEGIN;
|
|
SELECT count(*) FROM test_index_creation1;
|
|
count
|
|
---------------------------------------------------------------------
|
|
0
|
|
(1 row)
|
|
|
|
CREATE INDEX ix_test_index_creation4
|
|
ON test_index_creation1 USING btree
|
|
(tenant_id, timeperiod);
|
|
ERROR: The index name (test_index_creation1_p2020_09_26_xxxxxx_tenant_id_timeperiod_idx) on a shard is too long and could lead to deadlocks when executed in a transaction block after a parallel query
|
|
HINT: Try re-running the transaction with "SET LOCAL citus.multi_shard_modify_mode TO 'sequential';"
|
|
ROLLBACK;
|
|
-- try inside a sequential block
|
|
BEGIN;
|
|
SET LOCAL citus.multi_shard_modify_mode TO 'sequential';
|
|
SELECT count(*) FROM test_index_creation1;
|
|
count
|
|
---------------------------------------------------------------------
|
|
0
|
|
(1 row)
|
|
|
|
CREATE INDEX ix_test_index_creation4
|
|
ON test_index_creation1 USING btree
|
|
(tenant_id, timeperiod);
|
|
DEBUG: the index name on the shards of the partition is too long, switching to sequential and local execution mode to prevent self deadlocks: test_index_creation1_p2020_09_26_xxxxxx_tenant_id_timeperiod_idx
|
|
ROLLBACK;
|
|
-- should be able to create indexes with INCLUDE/WHERE
|
|
CREATE INDEX ix_test_index_creation5 ON test_index_creation1
|
|
USING btree(tenant_id, timeperiod)
|
|
INCLUDE (field1) WHERE (tenant_id = 100);
|
|
DEBUG: the index name on the shards of the partition is too long, switching to sequential and local execution mode to prevent self deadlocks: test_index_creation1_p2020_09_2_tenant_id_timeperiod_field1_idx
|
|
CREATE UNIQUE INDEX ix_test_index_creation6 ON test_index_creation1
|
|
USING btree(tenant_id, timeperiod);
|
|
DEBUG: the index name on the shards of the partition is too long, switching to sequential and local execution mode to prevent self deadlocks: test_index_creation1_p2020_09_26_xxxxxx_tenant_id_timeperiod_idx
|
|
-- should be able to create short named indexes in parallel
|
|
-- as the table/index name is short
|
|
CREATE INDEX f1
|
|
ON test_index_creation1 USING btree
|
|
(field1);
|
|
-- should be able to create index only for parent on both
|
|
-- coordinator and worker nodes
|
|
CREATE INDEX parent_index
|
|
ON ONLY test_index_creation1 USING btree
|
|
(field1);
|
|
-- show that we have parent index only on the parent table not on the partitions
|
|
SELECT count(*) FROM pg_index WHERE indrelid::regclass::text = 'test_index_creation1' AND indexrelid::regclass::text = 'parent_index';
|
|
count
|
|
---------------------------------------------------------------------
|
|
1
|
|
(1 row)
|
|
|
|
SELECT count(*) FROM pg_index WHERE indrelid::regclass::text LIKE 'test_index_creation1_p2020%' AND indexrelid::regclass::text LIKE 'parent_index%';
|
|
count
|
|
---------------------------------------------------------------------
|
|
0
|
|
(1 row)
|
|
|
|
\c - - - :worker_1_port
|
|
SET search_path TO multi_index_statements;
|
|
-- show that we have parent index_* only on the parent shards not on the partition shards
|
|
SELECT count(*) FROM pg_index WHERE indrelid::regclass::text LIKE 'test_index_creation1_%' AND indexrelid::regclass::text LIKE 'parent_index%';
|
|
count
|
|
---------------------------------------------------------------------
|
|
16
|
|
(1 row)
|
|
|
|
SELECT count(*) FROM pg_index WHERE indrelid::regclass::text LIKE 'test_index_creation1_p2020%' AND indexrelid::regclass::text LIKE 'parent_index%';
|
|
count
|
|
---------------------------------------------------------------------
|
|
0
|
|
(1 row)
|
|
|
|
\c - - - :master_port
|
|
SET search_path TO multi_index_statements;
|
|
-- attach child index of a partition to parent index of the partitioned table
|
|
CREATE INDEX child_index
|
|
ON test_index_creation1_p2020_09_26 USING btree
|
|
(field1);
|
|
ALTER INDEX parent_index ATTACH PARTITION child_index;
|
|
-- show that child index inherits from parent index which means it is attached to it
|
|
SELECT count(*) FROM pg_inherits WHERE inhrelid::regclass::text = 'child_index' AND inhparent::regclass::text = 'parent_index';
|
|
count
|
|
---------------------------------------------------------------------
|
|
1
|
|
(1 row)
|
|
|
|
\c - - - :worker_1_port
|
|
SET search_path TO multi_index_statements;
|
|
-- show that child indices of partition shards also inherit from parent indices of parent shards
|
|
SELECT count(*) FROM pg_inherits WHERE inhrelid::regclass::text LIKE 'child_index\_%' AND inhparent::regclass::text LIKE 'parent_index\_%';
|
|
count
|
|
---------------------------------------------------------------------
|
|
16
|
|
(1 row)
|
|
|
|
\c - - - :master_port
|
|
SET search_path TO multi_index_statements;
|
|
-- verify error check for partitioned index
|
|
ALTER INDEX parent_index SET TABLESPACE foo;
|
|
ERROR: alter index ... set tablespace ... is currently unsupported
|
|
DETAIL: Only RENAME TO, SET (), RESET (), ATTACH PARTITION and SET STATISTICS are supported.
|
|
-- drop parent index and show that child index will also be dropped
|
|
DROP INDEX parent_index;
|
|
SELECT count(*) FROM pg_index where indexrelid::regclass::text = 'child_index';
|
|
count
|
|
---------------------------------------------------------------------
|
|
0
|
|
(1 row)
|
|
|
|
-- show that having a foreign key to reference table causes sequential execution mode
|
|
-- with ALTER INDEX ... ATTACH PARTITION
|
|
CREATE TABLE index_creation_reference_table (id int primary key);
|
|
SELECT create_reference_table('index_creation_reference_table');
|
|
create_reference_table
|
|
---------------------------------------------------------------------
|
|
|
|
(1 row)
|
|
|
|
ALTER TABLE test_index_creation1 ADD CONSTRAINT foreign_key_to_ref_table
|
|
FOREIGN KEY (tenant_id)
|
|
REFERENCES index_creation_reference_table (id);
|
|
CREATE INDEX parent_index ON ONLY test_index_creation1 USING btree (field1);
|
|
CREATE INDEX child_index ON test_index_creation1_p2020_09_26 USING btree (field1);
|
|
BEGIN;
|
|
show citus.multi_shard_modify_mode;
|
|
citus.multi_shard_modify_mode
|
|
---------------------------------------------------------------------
|
|
parallel
|
|
(1 row)
|
|
|
|
ALTER INDEX parent_index ATTACH PARTITION child_index;
|
|
show citus.multi_shard_modify_mode;
|
|
citus.multi_shard_modify_mode
|
|
---------------------------------------------------------------------
|
|
sequential
|
|
(1 row)
|
|
|
|
ROLLBACK;
|
|
DROP TABLE index_creation_reference_table CASCADE;
|
|
NOTICE: drop cascades to constraint foreign_key_to_ref_table on table test_index_creation1
|
|
SELECT
|
|
'CREATE TABLE distributed_table(' ||
|
|
string_Agg('col' || x::text || ' int,', ' ') ||
|
|
' last_column int)'
|
|
FROM
|
|
generate_Series(1, 32) x;
|
|
?column?
|
|
---------------------------------------------------------------------
|
|
CREATE TABLE distributed_table(col1 int, col2 int, col3 int, col4 int, col5 int, col6 int, col7 int, col8 int, col9 int, col10 int, col11 int, col12 int, col13 int, col14 int, col15 int, col16 int, col17 int, col18 int, col19 int, col20 int, col21 int, col22 int, col23 int, col24 int, col25 int, col26 int, col27 int, col28 int, col29 int, col30 int, col31 int, col32 int, last_column int)
|
|
(1 row)
|
|
|
|
\gexec
|
|
CREATE TABLE distributed_table(col1 int, col2 int, col3 int, col4 int, col5 int, col6 int, col7 int, col8 int, col9 int, col10 int, col11 int, col12 int, col13 int, col14 int, col15 int, col16 int, col17 int, col18 int, col19 int, col20 int, col21 int, col22 int, col23 int, col24 int, col25 int, col26 int, col27 int, col28 int, col29 int, col30 int, col31 int, col32 int, last_column int)
|
|
SELECT create_distributed_table('distributed_table', 'last_column');
|
|
create_distributed_table
|
|
---------------------------------------------------------------------
|
|
|
|
(1 row)
|
|
|
|
-- try to use all 33 columns to create the index
|
|
-- show that we error out as postgres would do
|
|
SELECT
|
|
'CREATE INDEX ON distributed_table(' ||
|
|
string_Agg('col' || x::text || ',', ' ') ||
|
|
' last_column)'
|
|
FROM
|
|
generate_Series(1, 32) x;
|
|
?column?
|
|
---------------------------------------------------------------------
|
|
CREATE INDEX ON distributed_table(col1, col2, col3, col4, col5, col6, col7, col8, col9, col10, col11, col12, col13, col14, col15, col16, col17, col18, col19, col20, col21, col22, col23, col24, col25, col26, col27, col28, col29, col30, col31, col32, last_column)
|
|
(1 row)
|
|
|
|
\gexec
|
|
CREATE INDEX ON distributed_table(col1, col2, col3, col4, col5, col6, col7, col8, col9, col10, col11, col12, col13, col14, col15, col16, col17, col18, col19, col20, col21, col22, col23, col24, col25, col26, col27, col28, col29, col30, col31, col32, last_column)
|
|
ERROR: cannot use more than 32 columns in an index
|
|
-- show that we generate different default index names
|
|
-- for the indexes with same parameters on the same relation
|
|
CREATE INDEX ON distributed_table(last_column);
|
|
CREATE INDEX ON distributed_table(last_column);
|
|
SELECT indexrelid::regclass FROM pg_index WHERE indrelid='distributed_table'::regclass ORDER BY indexrelid;
|
|
indexrelid
|
|
---------------------------------------------------------------------
|
|
distributed_table_last_column_idx
|
|
distributed_table_last_column_idx1
|
|
(2 rows)
|
|
|
|
-- test CREATE INDEX in plpgsql to verify that we don't break parse tree
|
|
CREATE OR REPLACE FUNCTION create_index_in_plpgsql()
|
|
RETURNS VOID AS
|
|
$BODY$
|
|
BEGIN
|
|
CREATE INDEX ON distributed_table(last_column);
|
|
END;
|
|
$BODY$ LANGUAGE plpgsql;
|
|
CREATE TABLE test_for_func(
|
|
a int
|
|
);
|
|
SELECT create_distributed_table('test_for_func', 'a');
|
|
create_distributed_table
|
|
---------------------------------------------------------------------
|
|
|
|
(1 row)
|
|
|
|
-- create a function that depends on a relation that depends on an extension
|
|
CREATE OR REPLACE FUNCTION function_on_table_depends_on_extension (
|
|
p_table_name text)
|
|
RETURNS TABLE (LIKE pg_dist_partition)
|
|
AS $$
|
|
BEGIN
|
|
RETURN QUERY
|
|
SELECT * FROM pg_dist_partition WHERE logicalrelid::regclass::text = p_table_name;
|
|
END;
|
|
$$ LANGUAGE plpgsql;
|
|
SELECT logicalrelid FROM function_on_table_depends_on_extension('test_for_func');
|
|
logicalrelid
|
|
---------------------------------------------------------------------
|
|
test_for_func
|
|
(1 row)
|
|
|
|
-- create a function that depends on a relation that does not depend on an extension
|
|
CREATE TABLE local_test(a int);
|
|
CREATE OR REPLACE FUNCTION function_on_table_does_not_depend_on_extension (
|
|
input int)
|
|
RETURNS TABLE (LIKE local_test)
|
|
AS $$
|
|
BEGIN
|
|
RETURN QUERY
|
|
SELECT * FROM local_test WHERE a = input;
|
|
END;
|
|
$$ LANGUAGE plpgsql;
|
|
WARNING: "function function_on_table_does_not_depend_on_extension(integer)" has dependency to "table local_test" that is not in Citus' metadata
|
|
DETAIL: "function function_on_table_does_not_depend_on_extension(integer)" will be created only locally
|
|
HINT: Distribute "table local_test" first to distribute "function function_on_table_does_not_depend_on_extension(integer)"
|
|
SELECT * FROM function_on_table_does_not_depend_on_extension(5);
|
|
a
|
|
---------------------------------------------------------------------
|
|
(0 rows)
|
|
|
|
-- hide plpgsql messages as they differ across pg versions
|
|
\set VERBOSITY terse
|
|
SELECT create_index_in_plpgsql();
|
|
create_index_in_plpgsql
|
|
---------------------------------------------------------------------
|
|
|
|
(1 row)
|
|
|
|
SELECT create_index_in_plpgsql();
|
|
create_index_in_plpgsql
|
|
---------------------------------------------------------------------
|
|
|
|
(1 row)
|
|
|
|
SELECT create_index_in_plpgsql();
|
|
create_index_in_plpgsql
|
|
---------------------------------------------------------------------
|
|
|
|
(1 row)
|
|
|
|
SELECT indexrelid::regclass FROM pg_index WHERE indrelid='distributed_table'::regclass ORDER BY indexrelid;
|
|
indexrelid
|
|
---------------------------------------------------------------------
|
|
distributed_table_last_column_idx
|
|
distributed_table_last_column_idx1
|
|
distributed_table_last_column_idx2
|
|
distributed_table_last_column_idx3
|
|
distributed_table_last_column_idx4
|
|
(5 rows)
|
|
|
|
SET citus.force_max_query_parallelization TO OFF;
|
|
SET client_min_messages TO ERROR;
|
|
DROP INDEX f1;
|
|
DROP INDEX ix_test_index_creation2;
|
|
DROP INDEX ix_test_index_creation1_ix_test_index_creation1_ix_test_index_creation1_ix_test_index_creation1_ix_test_index_creation1;
|
|
DROP INDEX CONCURRENTLY ith_b_idx;
|
|
ERROR: index "ith_b_idx_102089" does not exist
|
|
-- the failure results in an INVALID index
|
|
SELECT indisvalid AS "Index Valid?" FROM pg_index WHERE indexrelid='ith_b_idx'::regclass;
|
|
Index Valid?
|
|
---------------------------------------------------------------------
|
|
f
|
|
(1 row)
|
|
|
|
-- final clean up
|
|
DROP INDEX CONCURRENTLY IF EXISTS ith_b_idx;
|
|
DROP SCHEMA multi_index_statements CASCADE;
|
|
DROP SCHEMA multi_index_statements_2 CASCADE;
|