ALTER SEQUENCE pg_catalog.pg_dist_shardid_seq RESTART 1250000;
CREATE TABLE reference_table_test (value_1 int, value_2 float, value_3 text, value_4 timestamp);
-- insert some data, and make sure that cannot be create_distributed_table
INSERT INTO reference_table_test VALUES (1, 1.0, '1', '2016-12-01');
-- create the reference table
SELECT create_reference_table('reference_table_test');
NOTICE:  Copying data from local table...
 create_reference_table 
------------------------
 
(1 row)

-- see that partkey is NULL
SELECT
	partmethod, (partkey IS NULL) as partkeyisnull, colocationid, repmodel
FROM
	pg_dist_partition
WHERE
	logicalrelid = 'reference_table_test'::regclass;
 partmethod | partkeyisnull | colocationid | repmodel 
------------+---------------+--------------+----------
 n          | t             |            1 | t
(1 row)

-- now see that shard min/max values are NULL
SELECT
	shardid, (shardminvalue IS NULL) as shardminvalueisnull, (shardmaxvalue IS NULL) as shardmaxvalueisnull
FROM
	pg_dist_shard
WHERE
	logicalrelid = 'reference_table_test'::regclass;
 shardid | shardminvalueisnull | shardmaxvalueisnull 
---------+---------------------+---------------------
 1250000 | t                   | t
(1 row)

SELECT
	shardid, shardstate, nodename, nodeport
FROM
	pg_dist_shard_placement
WHERE
	shardid IN (SELECT shardid FROM pg_dist_shard WHERE logicalrelid = 'reference_table_test'::regclass)
ORDER BY
	placementid;
 shardid | shardstate | nodename  | nodeport 
---------+------------+-----------+----------
 1250000 |          1 | localhost |    57637
 1250000 |          1 | localhost |    57638
(2 rows)

-- check whether data was copied into distributed table
SELECT * FROM reference_table_test;
 value_1 | value_2 | value_3 |         value_4          
---------+---------+---------+--------------------------
       1 |       1 | 1       | Thu Dec 01 00:00:00 2016
(1 row)

-- now, execute some modification queries
INSERT INTO reference_table_test VALUES (2, 2.0, '2', '2016-12-02');
INSERT INTO reference_table_test VALUES (3, 3.0, '3', '2016-12-03');
INSERT INTO reference_table_test VALUES (4, 4.0, '4', '2016-12-04');
INSERT INTO reference_table_test VALUES (5, 5.0, '5', '2016-12-05');
-- most of the queries in this file are already tested on multi_router_planner.sql
-- However, for the sake of completeness we need to run similar tests with
-- reference tables as well
-- run some queries on top of the data
SELECT
	*
FROM
	reference_table_test;
 value_1 | value_2 | value_3 |         value_4          
---------+---------+---------+--------------------------
       1 |       1 | 1       | Thu Dec 01 00:00:00 2016
       2 |       2 | 2       | Fri Dec 02 00:00:00 2016
       3 |       3 | 3       | Sat Dec 03 00:00:00 2016
       4 |       4 | 4       | Sun Dec 04 00:00:00 2016
       5 |       5 | 5       | Mon Dec 05 00:00:00 2016
(5 rows)

SELECT
	*
FROM
	reference_table_test
WHERE
	value_1 = 1;
 value_1 | value_2 | value_3 |         value_4          
---------+---------+---------+--------------------------
       1 |       1 | 1       | Thu Dec 01 00:00:00 2016
(1 row)

SELECT
	value_1,
	value_2
FROM
	reference_table_test
ORDER BY
	2 ASC LIMIT 3;
 value_1 | value_2 
---------+---------
       1 |       1
       2 |       2
       3 |       3
(3 rows)

SELECT
	value_1, value_3
FROM
	reference_table_test
WHERE
	value_2 >= 4
ORDER BY
	2 LIMIT 3;
 value_1 | value_3 
---------+---------
       4 | 4
       5 | 5
(2 rows)

SELECT
	value_1, 15 * value_2
FROM
	reference_table_test
ORDER BY
	2 ASC
LIMIT 2;
 value_1 | ?column? 
---------+----------
       1 |       15
       2 |       30
(2 rows)

SELECT
	value_1, 15 * value_2
FROM
	reference_table_test
ORDER BY
	2 ASC LIMIT 2 OFFSET 2;
 value_1 | ?column? 
---------+----------
       3 |       45
       4 |       60
(2 rows)

SELECT
	value_2, value_4
FROM
	reference_table_test
WHERE
	value_2 = 2 OR value_2 = 3;
 value_2 |         value_4          
---------+--------------------------
       2 | Fri Dec 02 00:00:00 2016
       3 | Sat Dec 03 00:00:00 2016
(2 rows)

SELECT
	value_2, value_4
FROM
	reference_table_test
WHERE
	value_2 = 2 AND value_2 = 3;
 value_2 | value_4 
---------+---------
(0 rows)

SELECT
	value_2, value_4
FROM
	reference_table_test
WHERE
	value_3 = '2' OR value_1 = 3;
 value_2 |         value_4          
---------+--------------------------
       2 | Fri Dec 02 00:00:00 2016
       3 | Sat Dec 03 00:00:00 2016
(2 rows)

SELECT
	value_2, value_4
FROM
	reference_table_test
WHERE
	(
		value_3 = '2' OR value_1 = 3
	)
	AND FALSE;
 value_2 | value_4 
---------+---------
(0 rows)

SELECT
	*
FROM
	reference_table_test
WHERE
	value_2 IN
	(
		SELECT
			value_3::FLOAT
		FROM
			reference_table_test
	)
	AND value_1 < 3;
 value_1 | value_2 | value_3 |         value_4          
---------+---------+---------+--------------------------
       1 |       1 | 1       | Thu Dec 01 00:00:00 2016
       2 |       2 | 2       | Fri Dec 02 00:00:00 2016
(2 rows)

SELECT
	value_4
FROM
	reference_table_test
WHERE
	value_3 IN
	(
		'1', '2'
	);
         value_4          
--------------------------
 Thu Dec 01 00:00:00 2016
 Fri Dec 02 00:00:00 2016
(2 rows)

SELECT
	date_part('day', value_4)
FROM
	reference_table_test
WHERE
	value_3 IN
	(
		'5', '2'
	);
 date_part 
-----------
         2
         5
(2 rows)

SELECT
	value_4
FROM
	reference_table_test
WHERE
	value_2 <= 2 AND value_2 >= 4;
 value_4 
---------
(0 rows)

SELECT
	value_4
FROM
	reference_table_test
WHERE
	value_2 <= 20 AND value_2 >= 4;
         value_4          
--------------------------
 Sun Dec 04 00:00:00 2016
 Mon Dec 05 00:00:00 2016
(2 rows)

SELECT
	value_4
FROM
	reference_table_test
WHERE
	value_2 >= 5 AND value_2 <= random();
 value_4 
---------
(0 rows)

SELECT
	value_1
FROM
	reference_table_test
WHERE
	value_4 BETWEEN '2016-12-01' AND '2016-12-03';
 value_1 
---------
       1
       2
       3
(3 rows)

SELECT
	value_1
FROM
	reference_table_test
WHERE
	FALSE;
 value_1 
---------
(0 rows)

SELECT
	value_1
FROM
	reference_table_test
WHERE
	int4eq(1, 2);
 value_1 
---------
(0 rows)

-- rename output name and do some operations
SELECT
	value_1 as id, value_2 * 15 as age
FROM
	reference_table_test;
 id | age 
----+-----
  1 |  15
  2 |  30
  3 |  45
  4 |  60
  5 |  75
(5 rows)

-- queries with CTEs are supported
WITH some_data AS ( SELECT value_2, value_4 FROM reference_table_test WHERE value_2 >=3)
SELECT
	*
FROM
	some_data;
 value_2 |         value_4          
---------+--------------------------
       3 | Sat Dec 03 00:00:00 2016
       4 | Sun Dec 04 00:00:00 2016
       5 | Mon Dec 05 00:00:00 2016
(3 rows)

-- queries with CTEs are supported even if CTE is not referenced inside query
WITH some_data AS ( SELECT value_2, value_4 FROM reference_table_test WHERE value_2 >=3)
SELECT * FROM reference_table_test ORDER BY 1 LIMIT 1;
 value_1 | value_2 | value_3 |         value_4          
---------+---------+---------+--------------------------
       1 |       1 | 1       | Thu Dec 01 00:00:00 2016
(1 row)

-- queries which involve functions in FROM clause are supported if it goes to a single worker.
SELECT
	*
FROM
	reference_table_test, position('om' in 'Thomas')
WHERE
	value_1 = 1;
 value_1 | value_2 | value_3 |         value_4          | position 
---------+---------+---------+--------------------------+----------
       1 |       1 | 1       | Thu Dec 01 00:00:00 2016 |        3
(1 row)

SELECT
	*
FROM
	reference_table_test, position('om' in 'Thomas')
WHERE
	value_1 = 1 OR value_1 = 2;
 value_1 | value_2 | value_3 |         value_4          | position 
---------+---------+---------+--------------------------+----------
       1 |       1 | 1       | Thu Dec 01 00:00:00 2016 |        3
       2 |       2 | 2       | Fri Dec 02 00:00:00 2016 |        3
(2 rows)

-- set operations are supported
SELECT * FROM (
	SELECT * FROM reference_table_test WHERE value_1 = 1
	UNION
	SELECT * FROM reference_table_test WHERE value_1 = 3
) AS combination
ORDER BY value_1;
 value_1 | value_2 | value_3 |         value_4          
---------+---------+---------+--------------------------
       1 |       1 | 1       | Thu Dec 01 00:00:00 2016
       3 |       3 | 3       | Sat Dec 03 00:00:00 2016
(2 rows)

SELECT * FROM (
	SELECT * FROM reference_table_test WHERE value_1 = 1
	EXCEPT
	SELECT * FROM reference_table_test WHERE value_1 = 3
) AS combination
ORDER BY value_1;
 value_1 | value_2 | value_3 |         value_4          
---------+---------+---------+--------------------------
       1 |       1 | 1       | Thu Dec 01 00:00:00 2016
(1 row)

SELECT * FROM (
	SELECT * FROM reference_table_test WHERE value_1 = 1
	INTERSECT
	SELECT * FROM reference_table_test WHERE value_1 = 3
) AS combination
ORDER BY value_1;
 value_1 | value_2 | value_3 | value_4 
---------+---------+---------+---------
(0 rows)

-- to make the tests more interested for aggregation tests, ingest some more data
INSERT INTO reference_table_test VALUES (1, 1.0, '1', '2016-12-01');
INSERT INTO reference_table_test VALUES (2, 2.0, '2', '2016-12-02');
INSERT INTO reference_table_test VALUES (3, 3.0, '3', '2016-12-03');
-- some aggregations
SELECT
	value_4, SUM(value_2)
FROM
	reference_table_test
GROUP BY
	value_4
HAVING
	SUM(value_2) > 3
ORDER BY
	1;
         value_4          | sum 
--------------------------+-----
 Fri Dec 02 00:00:00 2016 |   4
 Sat Dec 03 00:00:00 2016 |   6
 Sun Dec 04 00:00:00 2016 |   4
 Mon Dec 05 00:00:00 2016 |   5
(4 rows)

SELECT
	value_4,
	value_3,
	SUM(value_2)
FROM
	reference_table_test
GROUP BY
	GROUPING sets ((value_4), (value_3))
ORDER BY 1, 2, 3;
         value_4          | value_3 | sum 
--------------------------+---------+-----
 Thu Dec 01 00:00:00 2016 |         |   2
 Fri Dec 02 00:00:00 2016 |         |   4
 Sat Dec 03 00:00:00 2016 |         |   6
 Sun Dec 04 00:00:00 2016 |         |   4
 Mon Dec 05 00:00:00 2016 |         |   5
                          | 1       |   2
                          | 2       |   4
                          | 3       |   6
                          | 4       |   4
                          | 5       |   5
(10 rows)

-- distinct clauses also work fine
SELECT DISTINCT
	value_4
FROM
	reference_table_test
ORDER BY
	1;
         value_4          
--------------------------
 Thu Dec 01 00:00:00 2016
 Fri Dec 02 00:00:00 2016
 Sat Dec 03 00:00:00 2016
 Sun Dec 04 00:00:00 2016
 Mon Dec 05 00:00:00 2016
(5 rows)

-- window functions are also supported
SELECT
	value_4, RANK() OVER (PARTITION BY value_1 ORDER BY value_4)
FROM
	reference_table_test;
         value_4          | rank 
--------------------------+------
 Thu Dec 01 00:00:00 2016 |    1
 Thu Dec 01 00:00:00 2016 |    1
 Fri Dec 02 00:00:00 2016 |    1
 Fri Dec 02 00:00:00 2016 |    1
 Sat Dec 03 00:00:00 2016 |    1
 Sat Dec 03 00:00:00 2016 |    1
 Sun Dec 04 00:00:00 2016 |    1
 Mon Dec 05 00:00:00 2016 |    1
(8 rows)

-- window functions are also supported
SELECT
	value_4, AVG(value_1) OVER (PARTITION BY value_4 ORDER BY value_4)
FROM
	reference_table_test;
         value_4          |          avg           
--------------------------+------------------------
 Thu Dec 01 00:00:00 2016 | 1.00000000000000000000
 Thu Dec 01 00:00:00 2016 | 1.00000000000000000000
 Fri Dec 02 00:00:00 2016 |     2.0000000000000000
 Fri Dec 02 00:00:00 2016 |     2.0000000000000000
 Sat Dec 03 00:00:00 2016 |     3.0000000000000000
 Sat Dec 03 00:00:00 2016 |     3.0000000000000000
 Sun Dec 04 00:00:00 2016 |     4.0000000000000000
 Mon Dec 05 00:00:00 2016 |     5.0000000000000000
(8 rows)

SELECT
	count(DISTINCT CASE
			WHEN
				value_2 >= 3
			THEN
				value_2
			ELSE
				NULL
			END) as c
	FROM
		reference_table_test;
 c 
---
 3
(1 row)

SELECT
	value_1,
	count(DISTINCT CASE
			WHEN
				value_2 >= 3
			THEN
				value_2
			ELSE
				NULL
			END) as c
	FROM
		reference_table_test
	GROUP BY
		value_1
	ORDER BY
		1;
 value_1 | c 
---------+---
       1 | 0
       2 | 0
       3 | 1
       4 | 1
       5 | 1
(5 rows)

-- selects inside a transaction works fine as well
BEGIN;
SELECT * FROM reference_table_test;
 value_1 | value_2 | value_3 |         value_4          
---------+---------+---------+--------------------------
       1 |       1 | 1       | Thu Dec 01 00:00:00 2016
       2 |       2 | 2       | Fri Dec 02 00:00:00 2016
       3 |       3 | 3       | Sat Dec 03 00:00:00 2016
       4 |       4 | 4       | Sun Dec 04 00:00:00 2016
       5 |       5 | 5       | Mon Dec 05 00:00:00 2016
       1 |       1 | 1       | Thu Dec 01 00:00:00 2016
       2 |       2 | 2       | Fri Dec 02 00:00:00 2016
       3 |       3 | 3       | Sat Dec 03 00:00:00 2016
(8 rows)

SELECT * FROM reference_table_test WHERE value_1 = 1;
 value_1 | value_2 | value_3 |         value_4          
---------+---------+---------+--------------------------
       1 |       1 | 1       | Thu Dec 01 00:00:00 2016
       1 |       1 | 1       | Thu Dec 01 00:00:00 2016
(2 rows)

END;
-- cursor queries also works fine
BEGIN;
DECLARE test_cursor CURSOR FOR
	SELECT *
		FROM reference_table_test
		WHERE value_1 = 1 OR value_1 = 2
		ORDER BY value_1;
FETCH test_cursor;
 value_1 | value_2 | value_3 |         value_4          
---------+---------+---------+--------------------------
       1 |       1 | 1       | Thu Dec 01 00:00:00 2016
(1 row)

FETCH ALL test_cursor;
 value_1 | value_2 | value_3 |         value_4          
---------+---------+---------+--------------------------
       1 |       1 | 1       | Thu Dec 01 00:00:00 2016
       2 |       2 | 2       | Fri Dec 02 00:00:00 2016
       2 |       2 | 2       | Fri Dec 02 00:00:00 2016
(3 rows)

FETCH test_cursor; -- fetch one row after the last
 value_1 | value_2 | value_3 | value_4 
---------+---------+---------+---------
(0 rows)

FETCH BACKWARD test_cursor;
 value_1 | value_2 | value_3 |         value_4          
---------+---------+---------+--------------------------
       2 |       2 | 2       | Fri Dec 02 00:00:00 2016
(1 row)

END;
-- table creation queries inside can be router plannable
CREATE TEMP TABLE temp_reference_test as
	SELECT *
	FROM reference_table_test
	WHERE value_1 = 1;
-- all kinds of joins are supported among reference tables
-- first create two more tables
CREATE TABLE reference_table_test_second (value_1 int, value_2 float, value_3 text, value_4 timestamp);
SELECT create_reference_table('reference_table_test_second');
 create_reference_table 
------------------------
 
(1 row)

CREATE TABLE reference_table_test_third (value_1 int, value_2 float, value_3 text, value_4 timestamp);
SELECT create_reference_table('reference_table_test_third');
 create_reference_table 
------------------------
 
(1 row)

-- ingest some data to both tables
INSERT INTO reference_table_test_second VALUES (1, 1.0, '1', '2016-12-01');
INSERT INTO reference_table_test_second VALUES (2, 2.0, '2', '2016-12-02');
INSERT INTO reference_table_test_second VALUES (3, 3.0, '3', '2016-12-03');
INSERT INTO reference_table_test_third VALUES (4, 4.0, '4', '2016-12-04');
INSERT INTO reference_table_test_third VALUES (5, 5.0, '5', '2016-12-05');
-- some very basic tests
SELECT
	DISTINCT t1.value_1
FROM
	reference_table_test t1, reference_table_test_second t2
WHERE
	t1.value_2 = t2.value_2
ORDER BY
	1;
 value_1 
---------
       1
       2
       3
(3 rows)

SELECT
	DISTINCT t1.value_1
FROM
	reference_table_test t1, reference_table_test_third t3
WHERE
	t1.value_2 = t3.value_2
ORDER BY
	1;
 value_1 
---------
       4
       5
(2 rows)

SELECT
	DISTINCT t2.value_1
FROM
	reference_table_test_second t2, reference_table_test_third t3
WHERE
	t2.value_2 = t3.value_2
ORDER BY
	1;
 value_1 
---------
(0 rows)

-- join on different columns and different data types via casts
SELECT
	DISTINCT t1.value_1
FROM
	reference_table_test t1, reference_table_test_second t2
WHERE
	t1.value_2 = t2.value_1
ORDER BY
	1;
 value_1 
---------
       1
       2
       3
(3 rows)

SELECT
	DISTINCT t1.value_1
FROM
	reference_table_test t1, reference_table_test_second t2
WHERE
	t1.value_2 = t2.value_3::int
ORDER BY
	1;
 value_1 
---------
       1
       2
       3
(3 rows)

SELECT
	DISTINCT t1.value_1
FROM
	reference_table_test t1, reference_table_test_second t2
WHERE
	t1.value_2 = date_part('day', t2.value_4)
ORDER BY
	1;
 value_1 
---------
       1
       2
       3
(3 rows)

-- ingest a common row to see more meaningful results with joins involving 3 tables
INSERT INTO reference_table_test_third VALUES (3, 3.0, '3', '2016-12-03');
SELECT
	DISTINCT t1.value_1
FROM
	reference_table_test t1, reference_table_test_second t2, reference_table_test_third t3
WHERE
	t1.value_2 = date_part('day', t2.value_4) AND t3.value_2 = t1.value_2
ORDER BY
	1;
 value_1 
---------
       3
(1 row)

-- same query on different columns
SELECT
	DISTINCT t1.value_1
FROM
	reference_table_test t1, reference_table_test_second t2, reference_table_test_third t3
WHERE
	t1.value_1 = date_part('day', t2.value_4) AND t3.value_2 = t1.value_1
ORDER BY
	1;
 value_1 
---------
       3
(1 row)

-- with the JOIN syntax
SELECT
	DISTINCT t1.value_1
FROM
	reference_table_test t1 JOIN reference_table_test_second t2 USING (value_1)
							JOIN reference_table_test_third t3 USING (value_1)
ORDER BY
	1;
 value_1 
---------
       3
(1 row)

-- and left/right joins
SELECT
	DISTINCT t1.value_1
FROM
	reference_table_test t1 LEFT JOIN reference_table_test_second t2 USING (value_1)
							LEFT JOIN reference_table_test_third t3 USING (value_1)
ORDER BY
	1;
 value_1 
---------
       1
       2
       3
       4
       5
(5 rows)

SELECT
	DISTINCT t1.value_1
FROM
	reference_table_test t1 RIGHT JOIN reference_table_test_second t2 USING (value_1)
							RIGHT JOIN reference_table_test_third t3 USING (value_1)
ORDER BY
	1;
 value_1 
---------
       3
        
(2 rows)

-- now, lets have some tests on UPSERTs and uniquness
CREATE TABLE reference_table_test_fourth (value_1 int, value_2 float PRIMARY KEY, value_3 text, value_4 timestamp);
SELECT create_reference_table('reference_table_test_fourth');
 create_reference_table 
------------------------
 
(1 row)

-- insert a row
INSERT INTO reference_table_test_fourth VALUES (1, 1.0, '1', '2016-12-01');
-- now get the unique key violation
INSERT INTO reference_table_test_fourth VALUES (1, 1.0, '1', '2016-12-01');
ERROR:  duplicate key value violates unique constraint "reference_table_test_fourth_pkey_1250003"
DETAIL:  Key (value_2)=(1) already exists.
CONTEXT:  while executing command on localhost:57637
-- now get null constraint violation due to primary key
INSERT INTO reference_table_test_fourth (value_1, value_3, value_4) VALUES (1, '1.0', '2016-12-01');
ERROR:  null value in column "value_2" violates not-null constraint
DETAIL:  Failing row contains (1, null, 1.0, 2016-12-01 00:00:00).
CONTEXT:  while executing command on localhost:57637
-- lets run some upserts
INSERT INTO reference_table_test_fourth VALUES (1, 1.0, '1', '2016-12-01') ON CONFLICT DO NOTHING RETURNING *;
 value_1 | value_2 | value_3 | value_4 
---------+---------+---------+---------
(0 rows)

INSERT INTO reference_table_test_fourth VALUES (1, 1.0, '10', '2016-12-01') ON CONFLICT (value_2) DO
	UPDATE SET value_3 = EXCLUDED.value_3, value_2 = EXCLUDED.value_2
	RETURNING *;
 value_1 | value_2 | value_3 |         value_4          
---------+---------+---------+--------------------------
       1 |       1 | 10      | Thu Dec 01 00:00:00 2016
(1 row)

-- update all columns
INSERT INTO reference_table_test_fourth VALUES (1, 1.0, '10', '2016-12-01') ON CONFLICT (value_2) DO
	UPDATE SET value_3 = EXCLUDED.value_3 || '+10', value_2 = EXCLUDED.value_2 + 10, value_1 = EXCLUDED.value_1 + 10, value_4 = '2016-12-10'
	RETURNING *;
 value_1 | value_2 | value_3 |         value_4          
---------+---------+---------+--------------------------
      11 |      11 | 10+10   | Sat Dec 10 00:00:00 2016
(1 row)

-- finally see that shard healths are OK
SELECT
	shardid, shardstate, nodename, nodeport
FROM
	pg_dist_shard_placement
WHERE
	shardid IN (SELECT shardid FROM pg_dist_shard WHERE logicalrelid = 'reference_table_test_fourth'::regclass)
ORDER BY
	placementid;
 shardid | shardstate | nodename  | nodeport 
---------+------------+-----------+----------
 1250003 |          1 | localhost |    57637
 1250003 |          1 | localhost |    57638
(2 rows)

-- let's not run some update/delete queries on arbitrary columns
DELETE FROM
	reference_table_test
WHERE
	value_1 = 1
RETURNING *;
 value_1 | value_2 | value_3 |         value_4          
---------+---------+---------+--------------------------
       1 |       1 | 1       | Thu Dec 01 00:00:00 2016
       1 |       1 | 1       | Thu Dec 01 00:00:00 2016
(2 rows)

DELETE FROM
	reference_table_test
WHERE
	value_4 = '2016-12-05'
RETURNING *;
 value_1 | value_2 | value_3 |         value_4          
---------+---------+---------+--------------------------
       5 |       5 | 5       | Mon Dec 05 00:00:00 2016
(1 row)

UPDATE
	reference_table_test
SET
	value_2 = 15
WHERE
	value_2 = 2
RETURNING *;
 value_1 | value_2 | value_3 |         value_4          
---------+---------+---------+--------------------------
       2 |      15 | 2       | Fri Dec 02 00:00:00 2016
       2 |      15 | 2       | Fri Dec 02 00:00:00 2016
(2 rows)

-- and some queries without any filters
UPDATE
	reference_table_test
SET
	value_2 = 15, value_1 = 45
RETURNING *;
 value_1 | value_2 | value_3 |         value_4          
---------+---------+---------+--------------------------
      45 |      15 | 3       | Sat Dec 03 00:00:00 2016
      45 |      15 | 4       | Sun Dec 04 00:00:00 2016
      45 |      15 | 3       | Sat Dec 03 00:00:00 2016
      45 |      15 | 2       | Fri Dec 02 00:00:00 2016
      45 |      15 | 2       | Fri Dec 02 00:00:00 2016
(5 rows)

DELETE FROM
	reference_table_test
RETURNING *;
 value_1 | value_2 | value_3 |         value_4          
---------+---------+---------+--------------------------
      45 |      15 | 3       | Sat Dec 03 00:00:00 2016
      45 |      15 | 4       | Sun Dec 04 00:00:00 2016
      45 |      15 | 3       | Sat Dec 03 00:00:00 2016
      45 |      15 | 2       | Fri Dec 02 00:00:00 2016
      45 |      15 | 2       | Fri Dec 02 00:00:00 2016
(5 rows)

-- some tests with function evaluation and sequences
CREATE TABLE reference_table_test_fifth (value_1 serial  PRIMARY KEY, value_2 float, value_3 text, value_4 timestamp);
SELECT create_reference_table('reference_table_test_fifth');
 create_reference_table 
------------------------
 
(1 row)

CREATE SEQUENCE example_ref_value_seq;
-- see that sequences work as expected
INSERT INTO
	reference_table_test_fifth (value_2) VALUES (2)
RETURNING value_1, value_2;
 value_1 | value_2 
---------+---------
       1 |       2
(1 row)

INSERT INTO
	reference_table_test_fifth (value_2) VALUES (2)
RETURNING value_1, value_2;
 value_1 | value_2 
---------+---------
       2 |       2
(1 row)

INSERT INTO
	reference_table_test_fifth (value_2, value_3) VALUES (nextval('example_ref_value_seq'), nextval('example_ref_value_seq')::text)
RETURNING value_1, value_2, value_3;
 value_1 | value_2 | value_3 
---------+---------+---------
       3 |       1 | 2
(1 row)

UPDATE
	reference_table_test_fifth SET value_4 = now()
WHERE
	value_1 = 1
RETURNING value_1, value_2, value_4 > '2000-01-01';
 value_1 | value_2 | ?column? 
---------+---------+----------
       1 |       2 | t
(1 row)

-- test copying FROM / TO
-- first delete all the data
DELETE FROM
	reference_table_test;
COPY reference_table_test FROM STDIN WITH CSV;
COPY reference_table_test (value_2, value_3, value_4) FROM STDIN WITH CSV;
COPY reference_table_test (value_3) FROM STDIN WITH CSV;
COPY reference_table_test FROM STDIN WITH CSV;
COPY reference_table_test TO STDOUT WITH CSV;
1,1,1,Fri Jan 01 00:00:00 2016
,2,2,Sat Jan 02 00:00:00 2016
,,3,
,,,
-- INSERT INTO SELECT among reference tables
DELETE FROM
	reference_table_test_second;
INSERT INTO
	reference_table_test_second
	SELECT
		*
	FROM
		reference_table_test
	RETURNING *;
 value_1 | value_2 | value_3 |         value_4          
---------+---------+---------+--------------------------
       1 |       1 | 1       | Fri Jan 01 00:00:00 2016
         |       2 | 2       | Sat Jan 02 00:00:00 2016
         |         | 3       | 
         |         |         | 
(4 rows)

INSERT INTO
	reference_table_test_second (value_2)
	SELECT
		reference_table_test.value_2
	FROM
		reference_table_test JOIN reference_table_test_second USING (value_1)
	RETURNING *;
 value_1 | value_2 | value_3 | value_4 
---------+---------+---------+---------
         |       1 |         | 
(1 row)

SET citus.shard_count TO 6;
SET citus.shard_replication_factor TO 2;
CREATE TABLE colocated_table_test (value_1 int, value_2 float, value_3 text, value_4 timestamp);
SELECT create_distributed_table('colocated_table_test', 'value_1');
 create_distributed_table 
--------------------------
 
(1 row)

CREATE TABLE colocated_table_test_2 (value_1 int, value_2 float, value_3 text, value_4 timestamp);
SELECT create_distributed_table('colocated_table_test_2', 'value_1');
 create_distributed_table 
--------------------------
 
(1 row)

DELETE FROM reference_table_test;
INSERT INTO reference_table_test VALUES (1, 1.0, '1', '2016-12-01');
INSERT INTO reference_table_test VALUES (2, 2.0, '2', '2016-12-02');
INSERT INTO colocated_table_test VALUES (1, 1.0, '1', '2016-12-01');
INSERT INTO colocated_table_test VALUES (2, 2.0, '2', '2016-12-02');
INSERT INTO colocated_table_test_2 VALUES (1, 1.0, '1', '2016-12-01');
INSERT INTO colocated_table_test_2 VALUES (2, 2.0, '2', '2016-12-02');
SET client_min_messages TO DEBUG1;
SET citus.log_multi_join_order TO TRUE;
SELECT 
	reference_table_test.value_1
FROM 
	reference_table_test, colocated_table_test
WHERE 
	colocated_table_test.value_1 = reference_table_test.value_1;
LOG:  join order: [ "colocated_table_test" ][ broadcast join "reference_table_test" ]
 value_1 
---------
       1
       2
(2 rows)

SELECT 
	colocated_table_test.value_2
FROM 
	reference_table_test, colocated_table_test 
WHERE 
	colocated_table_test.value_2 = reference_table_test.value_2;
LOG:  join order: [ "colocated_table_test" ][ broadcast join "reference_table_test" ]
 value_2 
---------
       1
       2
(2 rows)

SELECT 
	colocated_table_test.value_2
FROM 
	colocated_table_test, reference_table_test
WHERE 
	reference_table_test.value_1 = colocated_table_test.value_1;
LOG:  join order: [ "colocated_table_test" ][ broadcast join "reference_table_test" ]
 value_2 
---------
       1
       2
(2 rows)

SELECT 
	colocated_table_test.value_2 
FROM 
	reference_table_test, colocated_table_test, colocated_table_test_2
WHERE 
	colocated_table_test.value_2 = reference_table_test.value_2;
LOG:  join order: [ "colocated_table_test" ][ broadcast join "reference_table_test" ][ cartesian product "colocated_table_test_2" ]
ERROR:  cannot perform distributed planning on this query
DETAIL:  Cartesian products are currently unsupported
SELECT 
	colocated_table_test.value_2 
FROM 
	reference_table_test, colocated_table_test, colocated_table_test_2
WHERE 
	colocated_table_test.value_1 = colocated_table_test_2.value_1 AND colocated_table_test.value_2 = reference_table_test.value_2;
LOG:  join order: [ "colocated_table_test" ][ broadcast join "reference_table_test" ][ local partition join "colocated_table_test_2" ]
 value_2 
---------
       1
       2
(2 rows)

SET citus.task_executor_type to "task-tracker";
SELECT 
	colocated_table_test.value_2 
FROM 
	reference_table_test, colocated_table_test, colocated_table_test_2
WHERE 
	colocated_table_test.value_2 = colocated_table_test_2.value_2 AND colocated_table_test.value_2 = reference_table_test.value_2;
LOG:  join order: [ "colocated_table_test" ][ broadcast join "reference_table_test" ][ dual partition join "colocated_table_test_2" ]
 value_2 
---------
       1
       2
(2 rows)

SELECT 
	reference_table_test.value_2 
FROM 
	reference_table_test, colocated_table_test, colocated_table_test_2
WHERE 
	colocated_table_test.value_1 = reference_table_test.value_1 AND colocated_table_test_2.value_1 = reference_table_test.value_1;
LOG:  join order: [ "colocated_table_test" ][ broadcast join "reference_table_test" ][ dual partition join "colocated_table_test_2" ]
 value_2 
---------
       1
       2
(2 rows)

SET citus.log_multi_join_order TO FALSE;
SET citus.shard_count TO DEFAULT;
SET citus.task_executor_type to "real-time";
-- some INSERT .. SELECT queries that involve both hash distributed and reference tables
-- should go via coordinator since we're inserting into reference table where 
-- not all the participants are reference tables
INSERT INTO
	reference_table_test (value_1)
SELECT
	colocated_table_test.value_1
FROM
	colocated_table_test, colocated_table_test_2
WHERE
	colocated_table_test.value_1 = colocated_table_test_2.value_1;
DEBUG:  only reference tables may be queried when targeting a reference table with distributed INSERT ... SELECT
DEBUG:  Collecting INSERT ... SELECT results on coordinator
-- should go via coordinator, same as the above
INSERT INTO
	reference_table_test (value_1)
SELECT
	colocated_table_test.value_1
FROM
	colocated_table_test, reference_table_test
WHERE
	colocated_table_test.value_1 = reference_table_test.value_1;
DEBUG:  only reference tables may be queried when targeting a reference table with distributed INSERT ... SELECT
DEBUG:  Collecting INSERT ... SELECT results on coordinator
-- now, insert into the hash partitioned table and use reference 
-- tables in the SELECT queries
INSERT INTO
	colocated_table_test (value_1, value_2)
SELECT 
	colocated_table_test_2.value_1, reference_table_test.value_2
FROM
	colocated_table_test_2, reference_table_test
WHERE
	colocated_table_test_2.value_4 = reference_table_test.value_4
RETURNING value_1, value_2;
 value_1 | value_2 
---------+---------
       1 |       1
       2 |       2
(2 rows)

-- some more complex queries (Note that there are more complex queries in multi_insert_select.sql)
INSERT INTO
	colocated_table_test (value_1, value_2)
SELECT 
	colocated_table_test_2.value_1, reference_table_test.value_2
FROM
	colocated_table_test_2, reference_table_test
WHERE
	colocated_table_test_2.value_2 = reference_table_test.value_2
RETURNING value_1, value_2;
 value_1 | value_2 
---------+---------
       1 |       1
       2 |       2
(2 rows)

-- partition column value comes from reference table, goes via coordinator
INSERT INTO
	colocated_table_test (value_1, value_2)
SELECT
	reference_table_test.value_2, colocated_table_test_2.value_1
FROM
	colocated_table_test_2, reference_table_test
WHERE
	colocated_table_test_2.value_4 = reference_table_test.value_4;
DEBUG:  cannot perform distributed INSERT INTO ... SELECT because the partition columns in the source table and subquery do not match
DETAIL:  The data type of the target table's partition column should exactly match the data type of the corresponding simple column reference in the subquery.
DEBUG:  Collecting INSERT ... SELECT results on coordinator
INSERT INTO
	colocated_table_test (value_1, value_2)
SELECT
	reference_table_test.value_1, colocated_table_test_2.value_1
FROM
	colocated_table_test_2, reference_table_test
WHERE
	colocated_table_test_2.value_4 = reference_table_test.value_4;
DEBUG:  cannot perform distributed INSERT INTO ... SELECT becuase the partition columns in the source table and subquery do not match
DETAIL:  The target table's partition column should correspond to a partition column in the subquery.
DEBUG:  Collecting INSERT ... SELECT results on coordinator
RESET client_min_messages;
-- some tests for mark_tables_colocated
-- should error out
SELECT mark_tables_colocated('colocated_table_test_2', ARRAY['reference_table_test']);
ERROR:  cannot colocate tables colocated_table_test_2 and reference_table_test
DETAIL:  Replication models don't match for colocated_table_test_2 and reference_table_test.
-- should work sliently
SELECT mark_tables_colocated('reference_table_test', ARRAY['reference_table_test_fifth']);
 mark_tables_colocated 
-----------------------
 
(1 row)

-- ensure that reference tables on
-- different queries works as expected
CREATE SCHEMA reference_schema;
-- create with schema prefix
CREATE TABLE reference_schema.reference_table_test_sixth (value_1 serial  PRIMARY KEY, value_2 float, value_3 text, value_4 timestamp);
SELECT create_reference_table('reference_schema.reference_table_test_sixth');
 create_reference_table 
------------------------
 
(1 row)

SET search_path TO 'reference_schema';
-- create on the schema
CREATE TABLE reference_table_test_seventh (value_1 serial  PRIMARY KEY, value_2 float, value_3 text, value_4 timestamp);
SELECT create_reference_table('reference_table_test_seventh');
 create_reference_table 
------------------------
 
(1 row)

-- ingest some data
INSERT INTO reference_table_test_sixth VALUES (1, 1.0, '1', '2016-12-01');
INSERT INTO reference_table_test_seventh VALUES (1, 1.0, '1', '2016-12-01');
SET search_path TO 'public';
-- ingest some data
INSERT INTO reference_schema.reference_table_test_sixth VALUES (2, 2.0, '2', '2016-12-02');
INSERT INTO reference_schema.reference_table_test_seventh VALUES (2, 2.0, '2', '2016-12-02');
-- some basic queries
SELECT
	value_1
FROM
	reference_schema.reference_table_test_sixth;
 value_1 
---------
       1
       2
(2 rows)

SET search_path TO 'reference_schema';
SELECT
	reference_table_test_sixth.value_1
FROM
	reference_table_test_sixth, reference_table_test_seventh
WHERE
	reference_table_test_sixth.value_4 = reference_table_test_seventh.value_4;
 value_1 
---------
       1
       2
(2 rows)

-- last test with cross schemas
SET search_path TO 'public';
SELECT
	reftable.value_2, colocated_table_test_2.value_1
FROM
	colocated_table_test_2, reference_schema.reference_table_test_sixth as reftable
WHERE
	colocated_table_test_2.value_4 = reftable.value_4;
 value_2 | value_1 
---------+---------
       1 |       1
       2 |       2
(2 rows)

-- let's now test TRUNCATE and DROP TABLE 
-- delete all rows and ingest some data
DELETE FROM reference_table_test;
INSERT INTO reference_table_test VALUES (1, 1.0, '1', '2016-12-01');
INSERT INTO reference_table_test VALUES (2, 2.0, '2', '2016-12-02');
INSERT INTO reference_table_test VALUES (3, 3.0, '3', '2016-12-03');
INSERT INTO reference_table_test VALUES (4, 4.0, '4', '2016-12-04');
INSERT INTO reference_table_test VALUES (5, 5.0, '5', '2016-12-05');
SELECT
	count(*)
FROM
	reference_table_test;
 count 
-------
     5
(1 row)

-- truncate it and get the result back
TRUNCATE reference_table_test;
SELECT
	count(*)
FROM
	reference_table_test;
 count 
-------
     0
(1 row)

-- now try dropping one of the existing reference tables
-- and check the metadata
SELECT logicalrelid FROM pg_dist_partition WHERE logicalrelid::regclass::text LIKE '%reference_table_test_fifth%';
        logicalrelid        
----------------------------
 reference_table_test_fifth
(1 row)

SELECT logicalrelid FROM pg_dist_shard WHERE logicalrelid::regclass::text LIKE '%reference_table_test_fifth%';
        logicalrelid        
----------------------------
 reference_table_test_fifth
(1 row)

DROP TABLE reference_table_test_fifth;
SELECT logicalrelid FROM pg_dist_partition WHERE logicalrelid::regclass::text LIKE '%reference_table_test_fifth%';
 logicalrelid 
--------------
(0 rows)

SELECT logicalrelid FROM pg_dist_shard WHERE logicalrelid::regclass::text LIKE '%reference_table_test_fifth%';
 logicalrelid 
--------------
(0 rows)

-- now test DDL changes
CREATE TABLE reference_table_ddl (value_1 int, value_2 float, value_3 text, value_4 timestamp);
SELECT create_reference_table('reference_table_ddl');
 create_reference_table 
------------------------
 
(1 row)

-- CREATE & DROP index and check the workers
CREATE INDEX reference_index_1 ON reference_table_ddl(value_1);
NOTICE:  using one-phase commit for distributed DDL commands
HINT:  You can enable two-phase commit for extra safety with: SET citus.multi_shard_commit_protocol TO '2pc'
CREATE INDEX reference_index_2 ON reference_table_ddl(value_2, value_3);
-- should be able to create/drop UNIQUE index on a reference table
CREATE UNIQUE INDEX reference_index_3 ON reference_table_ddl(value_1);
-- should be able to add a column
ALTER TABLE reference_table_ddl ADD COLUMN value_5 INTEGER;
ALTER TABLE reference_table_ddl ALTER COLUMN value_5 SET DATA TYPE FLOAT;
ALTER TABLE reference_table_ddl DROP COLUMN value_1;
ALTER TABLE reference_table_ddl ALTER COLUMN value_2 SET DEFAULT 25.0;
ALTER TABLE reference_table_ddl ALTER COLUMN value_3 SET NOT NULL;
-- see that Citus applied all DDLs to the table
SELECT "Column", "Type", "Modifiers" FROM table_desc WHERE relid='public.reference_table_ddl'::regclass;
 Column  |            Type             |  Modifiers   
---------+-----------------------------+--------------
 value_2 | double precision            | default 25.0
 value_3 | text                        | not null
 value_4 | timestamp without time zone | 
 value_5 | double precision            | 
(4 rows)

\d reference_index_2
    Index "public.reference_index_2"
 Column  |       Type       | Definition 
---------+------------------+------------
 value_2 | double precision | value_2
 value_3 | text             | value_3
btree, for table "public.reference_table_ddl"

-- also to the shard placements
\c - - - :worker_1_port
SELECT "Column", "Type", "Modifiers" FROM table_desc WHERE relid='public.reference_table_ddl_1250019'::regclass;
 Column  |            Type             |  Modifiers   
---------+-----------------------------+--------------
 value_2 | double precision            | default 25.0
 value_3 | text                        | not null
 value_4 | timestamp without time zone | 
 value_5 | double precision            | 
(4 rows)

\d reference_index_2_1250019
Index "public.reference_index_2_1250019"
 Column  |       Type       | Definition 
---------+------------------+------------
 value_2 | double precision | value_2
 value_3 | text             | value_3
btree, for table "public.reference_table_ddl_1250019"

\c - - - :master_port
DROP INDEX reference_index_2;
NOTICE:  using one-phase commit for distributed DDL commands
HINT:  You can enable two-phase commit for extra safety with: SET citus.multi_shard_commit_protocol TO '2pc'
\c - - - :worker_1_port
SELECT "Column", "Type", "Modifiers" FROM table_desc WHERE relid='public.reference_table_ddl_1250019'::regclass;
 Column  |            Type             |  Modifiers   
---------+-----------------------------+--------------
 value_2 | double precision            | default 25.0
 value_3 | text                        | not null
 value_4 | timestamp without time zone | 
 value_5 | double precision            | 
(4 rows)

\di reference_index_2*
          List of relations
 Schema | Name | Type | Owner | Table 
--------+------+------+-------+-------
(0 rows)

\c - - - :master_port
-- as we expect, renaming and setting WITH OIDS does not work for reference tables
ALTER TABLE reference_table_ddl RENAME TO reference_table_ddl_test;
ERROR:  renaming distributed tables is currently unsupported
ALTER TABLE reference_table_ddl SET WITH OIDS;
ERROR:  alter table command is currently unsupported
DETAIL:  Only ADD|DROP COLUMN, SET|DROP NOT NULL, SET|DROP DEFAULT, ADD|DROP CONSTRAINT, ATTACH|DETACH PARTITION and TYPE subcommands are supported.
-- now test reference tables against some helper UDFs that Citus provides
-- cannot delete / drop shards from a reference table
SELECT master_apply_delete_command('DELETE FROM reference_table_ddl');
ERROR:  cannot delete from distributed table
DETAIL:  Delete statements on reference tables are not supported.
-- cannot add shards
SELECT master_create_empty_shard('reference_table_ddl');
ERROR:  relation "reference_table_ddl" is a reference table
DETAIL:  We currently don't support creating shards on reference tables
-- master_modify_multiple_shards works, but, does it make sense to use at all?
INSERT INTO reference_table_ddl (value_2, value_3) VALUES (7, 'aa');
SELECT master_modify_multiple_shards('DELETE FROM reference_table_ddl WHERE value_2 = 7');
 master_modify_multiple_shards 
-------------------------------
                             1
(1 row)

INSERT INTO reference_table_ddl (value_2, value_3) VALUES (7, 'bb');
SELECT master_modify_multiple_shards('DELETE FROM reference_table_ddl');
 master_modify_multiple_shards 
-------------------------------
                             1
(1 row)

-- get/update the statistics
SELECT part_storage_type, part_key, part_replica_count, part_max_size,
           part_placement_policy FROM master_get_table_metadata('reference_table_ddl');
 part_storage_type | part_key | part_replica_count | part_max_size | part_placement_policy 
-------------------+----------+--------------------+---------------+-----------------------
 t                 |          |                  2 |        307200 |                     2
(1 row)

SELECT shardid AS a_shard_id  FROM pg_dist_shard WHERE logicalrelid = 'reference_table_ddl'::regclass \gset
SELECT master_update_shard_statistics(:a_shard_id);
 master_update_shard_statistics 
--------------------------------
                          16384
(1 row)

CREATE TABLE append_reference_tmp_table (id INT);
SELECT  master_append_table_to_shard(:a_shard_id, 'append_reference_tmp_table', 'localhost', :master_port);
ERROR:  cannot append to shardId 1250019
DETAIL:  We currently don't support appending to shards in hash-partitioned or reference tables
SELECT master_get_table_ddl_events('reference_table_ddl');
                                                                      master_get_table_ddl_events                                                                      
-----------------------------------------------------------------------------------------------------------------------------------------------------------------------
 CREATE TABLE public.reference_table_ddl (value_2 double precision DEFAULT 25.0, value_3 text NOT NULL, value_4 timestamp without time zone, value_5 double precision)
(1 row)

-- in reality, we wouldn't need to repair any reference table shard placements
-- however, the test could be relevant for other purposes
SELECT placementid AS a_placement_id FROM pg_dist_shard_placement WHERE shardid = :a_shard_id AND nodeport = :worker_1_port \gset
SELECT placementid AS b_placement_id FROM pg_dist_shard_placement WHERE shardid = :a_shard_id AND nodeport = :worker_2_port \gset
UPDATE pg_dist_shard_placement SET shardstate = 3 WHERE placementid = :a_placement_id;
SELECT master_copy_shard_placement(:a_shard_id, 'localhost', :worker_2_port, 'localhost', :worker_1_port);
 master_copy_shard_placement 
-----------------------------
 
(1 row)

SELECT shardid, shardstate FROM pg_dist_shard_placement WHERE placementid = :a_placement_id;
 shardid | shardstate 
---------+------------
 1250019 |          1
(1 row)

-- some queries that are captured in functions
CREATE FUNCTION select_count_all() RETURNS bigint AS '
        SELECT
                count(*)
        FROM
                reference_table_test;
' LANGUAGE SQL;
CREATE FUNCTION insert_into_ref_table(value_1 int, value_2 float, value_3 text, value_4 timestamp) 
RETURNS void AS '
       INSERT INTO reference_table_test VALUES ($1, $2, $3, $4);
' LANGUAGE SQL;
TRUNCATE reference_table_test;
SELECT select_count_all();
 select_count_all 
------------------
                0
(1 row)

SELECT insert_into_ref_table(1, 1.0, '1', '2016-12-01');
 insert_into_ref_table 
-----------------------
 
(1 row)

SELECT insert_into_ref_table(2, 2.0, '2', '2016-12-02');
 insert_into_ref_table 
-----------------------
 
(1 row)

SELECT insert_into_ref_table(3, 3.0, '3', '2016-12-03');
 insert_into_ref_table 
-----------------------
 
(1 row)

SELECT insert_into_ref_table(4, 4.0, '4', '2016-12-04');
 insert_into_ref_table 
-----------------------
 
(1 row)

SELECT insert_into_ref_table(5, 5.0, '5', '2016-12-05');
 insert_into_ref_table 
-----------------------
 
(1 row)

SELECT insert_into_ref_table(6, 6.0, '6', '2016-12-06');
 insert_into_ref_table 
-----------------------
 
(1 row)

SELECT select_count_all();
 select_count_all 
------------------
                6
(1 row)

TRUNCATE reference_table_test;
-- some prepared queries and pl/pgsql functions
PREPARE insert_into_ref_table_pr (int, float, text, timestamp) 
	AS INSERT INTO reference_table_test VALUES ($1, $2, $3, $4);
-- reference tables do not have up-to-five execution limit as other tables
EXECUTE insert_into_ref_table_pr(1, 1.0, '1', '2016-12-01');
EXECUTE insert_into_ref_table_pr(2, 2.0, '2', '2016-12-02');
EXECUTE insert_into_ref_table_pr(3, 3.0, '3', '2016-12-03');
EXECUTE insert_into_ref_table_pr(4, 4.0, '4', '2016-12-04');
EXECUTE insert_into_ref_table_pr(5, 5.0, '5', '2016-12-05');
EXECUTE insert_into_ref_table_pr(6, 6.0, '6', '2016-12-06');
-- see the count, then truncate the table
SELECT select_count_all();
 select_count_all 
------------------
                6
(1 row)

TRUNCATE reference_table_test;
-- reference tables work with composite key
-- and we even do not need to create hash
-- function etc.
-- first create the type on all nodes
CREATE TYPE reference_comp_key as (key text, value text);
\c - - - :worker_1_port
CREATE TYPE reference_comp_key as (key text, value text);
\c - - - :worker_2_port
CREATE TYPE reference_comp_key as (key text, value text);
\c - - - :master_port
CREATE TABLE reference_table_composite (id int PRIMARY KEY, data reference_comp_key);
SELECT create_reference_table('reference_table_composite');
 create_reference_table 
------------------------
 
(1 row)

-- insert and query some data
INSERT INTO reference_table_composite (id, data) VALUES (1, ('key_1', 'value_1')::reference_comp_key);
INSERT INTO reference_table_composite (id, data) VALUES (2, ('key_2', 'value_2')::reference_comp_key);
SELECT * FROM reference_table_composite;
 id |      data       
----+-----------------
  1 | (key_1,value_1)
  2 | (key_2,value_2)
(2 rows)

SELECT (data).key FROM reference_table_composite;
  key  
-------
 key_1
 key_2
(2 rows)

-- make sure that reference tables obeys single shard transactions
TRUNCATE reference_table_test;
BEGIN;
INSERT INTO reference_table_test VALUES (1, 1.0, '1', '2016-12-01');
SELECT * FROM reference_table_test;
 value_1 | value_2 | value_3 |         value_4          
---------+---------+---------+--------------------------
       1 |       1 | 1       | Thu Dec 01 00:00:00 2016
(1 row)

ROLLBACK;
SELECT * FROM reference_table_test;
 value_1 | value_2 | value_3 | value_4 
---------+---------+---------+---------
(0 rows)

-- now insert a row and commit
BEGIN;
INSERT INTO reference_table_test VALUES (2, 2.0, '2', '2016-12-02');
COMMIT;
SELECT * FROM reference_table_test;
 value_1 | value_2 | value_3 |         value_4          
---------+---------+---------+--------------------------
       2 |       2 | 2       | Fri Dec 02 00:00:00 2016
(1 row)

-- one basic UPDATE test
BEGIN;
UPDATE reference_table_test SET value_1 = 10 WHERE value_1 = 2;
COMMIT;
SELECT * FROM reference_table_test;
 value_1 | value_2 | value_3 |         value_4          
---------+---------+---------+--------------------------
      10 |       2 | 2       | Fri Dec 02 00:00:00 2016
(1 row)

-- DML+master_modify_multiple_shards is allowed
BEGIN;
INSERT INTO reference_table_test VALUES (2, 2.0, '2', '2016-12-02');
SELECT master_modify_multiple_shards('DELETE FROM colocated_table_test');
 master_modify_multiple_shards 
-------------------------------
                            10
(1 row)

ROLLBACK;
-- DDL+DML is allowed
BEGIN;
ALTER TABLE reference_table_test ADD COLUMN value_dummy INT;
NOTICE:  using one-phase commit for distributed DDL commands
HINT:  You can enable two-phase commit for extra safety with: SET citus.multi_shard_commit_protocol TO '2pc'
INSERT INTO reference_table_test VALUES (2, 2.0, '2', '2016-12-02');
ROLLBACK;
-- clean up tables
DROP TABLE reference_table_test, reference_table_test_second, reference_table_test_third, 
		   reference_table_test_fourth, reference_table_ddl, reference_table_composite;
DROP SCHEMA reference_schema CASCADE;
NOTICE:  drop cascades to 2 other objects
DETAIL:  drop cascades to table reference_schema.reference_table_test_sixth
drop cascades to table reference_schema.reference_table_test_seventh