rdelaage
/
postgresql
mirror of https://git.postgresql.org/git/postgresql.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
postgresql/src/test/regress/expected/union.out

713 lines
15 KiB
Plaintext
Raw Blame History

--
-- UNION (also INTERSECT, EXCEPT)
--
-- Simple UNION constructs
SELECT 1 AS two UNION SELECT 2;
two
-----
1
2
(2 rows)
SELECT 1 AS one UNION SELECT 1;
one
-----
1
(1 row)
SELECT 1 AS two UNION ALL SELECT 2;
two
-----
1
2
(2 rows)
SELECT 1 AS two UNION ALL SELECT 1;
two
-----
1
1
(2 rows)
SELECT 1 AS three UNION SELECT 2 UNION SELECT 3;
three
-------
1
2
3
(3 rows)
SELECT 1 AS two UNION SELECT 2 UNION SELECT 2;
two
-----
1
2
(2 rows)
SELECT 1 AS three UNION SELECT 2 UNION ALL SELECT 2;
three
-------
1
2
2
(3 rows)
SELECT 1.1 AS two UNION SELECT 2.2;
two
-----
1.1
2.2
(2 rows)
-- Mixed types
SELECT 1.1 AS two UNION SELECT 2;
two
-----
1.1
2
(2 rows)
SELECT 1 AS two UNION SELECT 2.2;
two
-----
1
2.2
(2 rows)
SELECT 1 AS one UNION SELECT 1.0::float8;
one
-----
1
(1 row)
SELECT 1.1 AS two UNION ALL SELECT 2;
two
-----
1.1
2
(2 rows)
SELECT 1.0::float8 AS two UNION ALL SELECT 1;
two
-----
1
1
(2 rows)
SELECT 1.1 AS three UNION SELECT 2 UNION SELECT 3;
three
-------
1.1
2
3
(3 rows)
SELECT 1.1::float8 AS two UNION SELECT 2 UNION SELECT 2.0::float8 ORDER BY 1;
two
-----
1.1
2
(2 rows)
SELECT 1.1 AS three UNION SELECT 2 UNION ALL SELECT 2;
three
-------
1.1
2
2
(3 rows)
SELECT 1.1 AS two UNION (SELECT 2 UNION ALL SELECT 2);
two
-----
1.1
2
(2 rows)
--
-- Try testing from tables...
--
SELECT f1 AS five FROM FLOAT8_TBL
UNION
SELECT f1 FROM FLOAT8_TBL
ORDER BY 1;
five
-----------------------
-1.2345678901234e+200
-1004.3
-34.84
-1.2345678901234e-200
0
(5 rows)
SELECT f1 AS ten FROM FLOAT8_TBL
UNION ALL
SELECT f1 FROM FLOAT8_TBL;
ten
-----------------------
0
-34.84
-1004.3
-1.2345678901234e+200
-1.2345678901234e-200
0
-34.84
-1004.3
-1.2345678901234e+200
-1.2345678901234e-200
(10 rows)
SELECT f1 AS nine FROM FLOAT8_TBL
UNION
SELECT f1 FROM INT4_TBL
ORDER BY 1;
nine
-----------------------
-1.2345678901234e+200
-2147483647
-123456
-1004.3
-34.84
-1.2345678901234e-200
0
123456
2147483647
(9 rows)
SELECT f1 AS ten FROM FLOAT8_TBL
UNION ALL
SELECT f1 FROM INT4_TBL;
ten
-----------------------
0
-34.84
-1004.3
-1.2345678901234e+200
-1.2345678901234e-200
0
123456
-123456
2147483647
-2147483647
(10 rows)
SELECT f1 AS five FROM FLOAT8_TBL
WHERE f1 BETWEEN -1e6 AND 1e6
UNION
SELECT f1 FROM INT4_TBL
WHERE f1 BETWEEN 0 AND 1000000;
five
-----------------------
-1004.3
-34.84
-1.2345678901234e-200
0
123456
(5 rows)
SELECT CAST(f1 AS char(4)) AS three FROM VARCHAR_TBL
UNION
SELECT f1 FROM CHAR_TBL
ORDER BY 1;
three
-------
a
ab
abcd
(3 rows)
SELECT f1 AS three FROM VARCHAR_TBL
UNION
SELECT CAST(f1 AS varchar) FROM CHAR_TBL
ORDER BY 1;
three
-------
a
ab
abcd
(3 rows)
SELECT f1 AS eight FROM VARCHAR_TBL
UNION ALL
SELECT f1 FROM CHAR_TBL;
eight
-------
a
ab
abcd
abcd
a
ab
abcd
abcd
(8 rows)
SELECT f1 AS five FROM TEXT_TBL
UNION
SELECT f1 FROM VARCHAR_TBL
UNION
SELECT TRIM(TRAILING FROM f1) FROM CHAR_TBL
ORDER BY 1;
five
-------------------
a
ab
abcd
doh!
hi de ho neighbor
(5 rows)
--
-- INTERSECT and EXCEPT
--
SELECT q2 FROM int8_tbl INTERSECT SELECT q1 FROM int8_tbl;
q2
------------------
4567890123456789
123
(2 rows)
SELECT q2 FROM int8_tbl INTERSECT ALL SELECT q1 FROM int8_tbl;
q2
------------------
4567890123456789
4567890123456789
123
(3 rows)
SELECT q2 FROM int8_tbl EXCEPT SELECT q1 FROM int8_tbl ORDER BY 1;
q2
-------------------
-4567890123456789
456
(2 rows)
SELECT q2 FROM int8_tbl EXCEPT ALL SELECT q1 FROM int8_tbl ORDER BY 1;
q2
-------------------
-4567890123456789
456
(2 rows)
SELECT q2 FROM int8_tbl EXCEPT ALL SELECT DISTINCT q1 FROM int8_tbl ORDER BY 1;
q2
-------------------
-4567890123456789
456
4567890123456789
(3 rows)
SELECT q1 FROM int8_tbl EXCEPT SELECT q2 FROM int8_tbl;
q1
----
(0 rows)
SELECT q1 FROM int8_tbl EXCEPT ALL SELECT q2 FROM int8_tbl;
q1
------------------
4567890123456789
123
(2 rows)
SELECT q1 FROM int8_tbl EXCEPT ALL SELECT DISTINCT q2 FROM int8_tbl;
q1
------------------
4567890123456789
4567890123456789
123
(3 rows)
SELECT q1 FROM int8_tbl EXCEPT ALL SELECT q1 FROM int8_tbl FOR NO KEY UPDATE;
ERROR: FOR NO KEY UPDATE is not allowed with UNION/INTERSECT/EXCEPT
--
-- Mixed types
--
SELECT f1 FROM float8_tbl INTERSECT SELECT f1 FROM int4_tbl;
f1
----
0
(1 row)
SELECT f1 FROM float8_tbl EXCEPT SELECT f1 FROM int4_tbl ORDER BY 1;
f1
-----------------------
-1.2345678901234e+200
-1004.3
-34.84
-1.2345678901234e-200
(4 rows)
--
-- Operator precedence and (((((extra))))) parentheses
--
SELECT q1 FROM int8_tbl INTERSECT SELECT q2 FROM int8_tbl UNION ALL SELECT q2 FROM int8_tbl;
q1
-------------------
4567890123456789
123
456
4567890123456789
123
4567890123456789
-4567890123456789
(7 rows)
SELECT q1 FROM int8_tbl INTERSECT (((SELECT q2 FROM int8_tbl UNION ALL SELECT q2 FROM int8_tbl)));
q1
------------------
4567890123456789
123
(2 rows)
(((SELECT q1 FROM int8_tbl INTERSECT SELECT q2 FROM int8_tbl))) UNION ALL SELECT q2 FROM int8_tbl;
q1
-------------------
4567890123456789
123
456
4567890123456789
123
4567890123456789
-4567890123456789
(7 rows)
SELECT q1 FROM int8_tbl UNION ALL SELECT q2 FROM int8_tbl EXCEPT SELECT q1 FROM int8_tbl ORDER BY 1;
q1
-------------------
-4567890123456789
456
(2 rows)
SELECT q1 FROM int8_tbl UNION ALL (((SELECT q2 FROM int8_tbl EXCEPT SELECT q1 FROM int8_tbl ORDER BY 1)));
q1
-------------------
123
123
4567890123456789
4567890123456789
4567890123456789
-4567890123456789
456
(7 rows)
(((SELECT q1 FROM int8_tbl UNION ALL SELECT q2 FROM int8_tbl))) EXCEPT SELECT q1 FROM int8_tbl ORDER BY 1;
q1
-------------------
-4567890123456789
456
(2 rows)
--
-- Subqueries with ORDER BY & LIMIT clauses
--
-- In this syntax, ORDER BY/LIMIT apply to the result of the EXCEPT
SELECT q1,q2 FROM int8_tbl EXCEPT SELECT q2,q1 FROM int8_tbl
ORDER BY q2,q1;
q1 | q2
------------------+-------------------
4567890123456789 | -4567890123456789
123 | 456
(2 rows)
-- This should fail, because q2 isn't a name of an EXCEPT output column
SELECT q1 FROM int8_tbl EXCEPT SELECT q2 FROM int8_tbl ORDER BY q2 LIMIT 1;
ERROR: column "q2" does not exist
LINE 1: ... int8_tbl EXCEPT SELECT q2 FROM int8_tbl ORDER BY q2 LIMIT 1...
^
HINT: There is a column named "q2" in table "*SELECT* 2", but it cannot be referenced from this part of the query.
-- But this should work:
SELECT q1 FROM int8_tbl EXCEPT (((SELECT q2 FROM int8_tbl ORDER BY q2 LIMIT 1)));
q1
------------------
4567890123456789
123
(2 rows)
--
-- New syntaxes (7.1) permit new tests
--
(((((select * from int8_tbl)))));
q1 | q2
------------------+-------------------
123 | 456
123 | 4567890123456789
4567890123456789 | 123
4567890123456789 | 4567890123456789
4567890123456789 | -4567890123456789
(5 rows)
--
-- Check handling of a case with unknown constants. We don't guarantee
-- an undecorated constant will work in all cases, but historically this
-- usage has worked, so test we don't break it.
--
SELECT a.f1 FROM (SELECT 'test' AS f1 FROM varchar_tbl) a
UNION
SELECT b.f1 FROM (SELECT f1 FROM varchar_tbl) b
ORDER BY 1;
f1
------
a
ab
abcd
test
(4 rows)
-- This should fail, but it should produce an error cursor
SELECT '3.4'::numeric UNION SELECT 'foo';
ERROR: invalid input syntax for type numeric: "foo"
LINE 1: SELECT '3.4'::numeric UNION SELECT 'foo';
^
--
-- Test that expression-index constraints can be pushed down through
-- UNION or UNION ALL
--
CREATE TEMP TABLE t1 (a text, b text);
CREATE INDEX t1_ab_idx on t1 ((a || b));
CREATE TEMP TABLE t2 (ab text primary key);
INSERT INTO t1 VALUES ('a', 'b'), ('x', 'y');
INSERT INTO t2 VALUES ('ab'), ('xy');
set enable_seqscan = off;
set enable_indexscan = on;
set enable_bitmapscan = off;
explain (costs off)
SELECT * FROM
(SELECT a || b AS ab FROM t1
UNION ALL
SELECT * FROM t2) t
WHERE ab = 'ab';
QUERY PLAN
---------------------------------------------
Append
-> Index Scan using t1_ab_idx on t1
Index Cond: ((a || b) = 'ab'::text)
-> Index Only Scan using t2_pkey on t2
Index Cond: (ab = 'ab'::text)
(5 rows)
explain (costs off)
SELECT * FROM
(SELECT a || b AS ab FROM t1
UNION
SELECT * FROM t2) t
WHERE ab = 'ab';
QUERY PLAN
---------------------------------------------------
HashAggregate
Group Key: ((t1.a || t1.b))
-> Append
-> Index Scan using t1_ab_idx on t1
Index Cond: ((a || b) = 'ab'::text)
-> Index Only Scan using t2_pkey on t2
Index Cond: (ab = 'ab'::text)
(7 rows)
--
-- Test that ORDER BY for UNION ALL can be pushed down to inheritance
-- children.
--
CREATE TEMP TABLE t1c (b text, a text);
ALTER TABLE t1c INHERIT t1;
CREATE TEMP TABLE t2c (primary key (ab)) INHERITS (t2);
INSERT INTO t1c VALUES ('v', 'w'), ('c', 'd'), ('m', 'n'), ('e', 'f');
INSERT INTO t2c VALUES ('vw'), ('cd'), ('mn'), ('ef');
CREATE INDEX t1c_ab_idx on t1c ((a || b));
set enable_seqscan = on;
set enable_indexonlyscan = off;
explain (costs off)
SELECT * FROM
(SELECT a || b AS ab FROM t1
UNION ALL
SELECT ab FROM t2) t
ORDER BY 1 LIMIT 8;
QUERY PLAN
------------------------------------------------
Limit
-> Merge Append
Sort Key: ((t1.a || t1.b))
-> Index Scan using t1_ab_idx on t1
-> Index Scan using t1c_ab_idx on t1c
-> Index Scan using t2_pkey on t2
-> Index Scan using t2c_pkey on t2c
(7 rows)
SELECT * FROM
(SELECT a || b AS ab FROM t1
UNION ALL
SELECT ab FROM t2) t
ORDER BY 1 LIMIT 8;
ab
----
ab
ab
cd
dc
ef
fe
mn
nm
(8 rows)
reset enable_seqscan;
reset enable_indexscan;
reset enable_bitmapscan;
-- This simpler variant of the above test has been observed to fail differently
create table events (event_id int primary key);
create table other_events (event_id int primary key);
create table events_child () inherits (events);
explain (costs off)
select event_id
from (select event_id from events
union all
select event_id from other_events) ss
order by event_id;
QUERY PLAN
----------------------------------------------------------
Merge Append
Sort Key: events.event_id
-> Index Scan using events_pkey on events
-> Sort
Sort Key: events_child.event_id
-> Seq Scan on events_child
-> Index Scan using other_events_pkey on other_events
(7 rows)
drop table events_child, events, other_events;
reset enable_indexonlyscan;
-- Test constraint exclusion of UNION ALL subqueries
explain (costs off)
SELECT * FROM
(SELECT 1 AS t, * FROM tenk1 a
UNION ALL
SELECT 2 AS t, * FROM tenk1 b) c
WHERE t = 2;
QUERY PLAN
---------------------------
Append
-> Seq Scan on tenk1 b
(2 rows)
-- Test that we push quals into UNION sub-selects only when it's safe
explain (costs off)
SELECT * FROM
(SELECT 1 AS t, 2 AS x
UNION
SELECT 2 AS t, 4 AS x) ss
WHERE x < 4;
QUERY PLAN
--------------------------------------------
Unique
-> Sort
Sort Key: (1), (2)
-> Append
-> Result
-> Result
One-Time Filter: false
(7 rows)
SELECT * FROM
(SELECT 1 AS t, 2 AS x
UNION
SELECT 2 AS t, 4 AS x) ss
WHERE x < 4;
t | x
---+---
1 | 2
(1 row)
explain (costs off)
SELECT * FROM
(SELECT 1 AS t, generate_series(1,10) AS x
UNION
SELECT 2 AS t, 4 AS x) ss
WHERE x < 4
ORDER BY x;
QUERY PLAN
--------------------------------------------------------
Sort
Sort Key: ss.x
-> Subquery Scan on ss
Filter: (ss.x < 4)
-> HashAggregate
Group Key: (1), (generate_series(1, 10))
-> Append
-> Result
-> Result
(9 rows)
SELECT * FROM
(SELECT 1 AS t, generate_series(1,10) AS x
UNION
SELECT 2 AS t, 4 AS x) ss
WHERE x < 4
ORDER BY x;
t | x
---+---
1 | 1
1 | 2
1 | 3
(3 rows)
explain (costs off)
SELECT * FROM
(SELECT 1 AS t, (random()*3)::int AS x
UNION
SELECT 2 AS t, 4 AS x) ss
WHERE x > 3;
QUERY PLAN
------------------------------------------------------------------------------
Subquery Scan on ss
Filter: (ss.x > 3)
-> Unique
-> Sort
Sort Key: (1), (((random() * '3'::double precision))::integer)
-> Append
-> Result
-> Result
(8 rows)
SELECT * FROM
(SELECT 1 AS t, (random()*3)::int AS x
UNION
SELECT 2 AS t, 4 AS x) ss
WHERE x > 3;
t | x
---+---
2 | 4
(1 row)
-- Test proper handling of parameterized appendrel paths when the
-- potential join qual is expensive
create function expensivefunc(int) returns int
language plpgsql immutable strict cost 10000
as $$begin return $1; end$$;
create temp table t3 as select generate_series(-1000,1000) as x;
create index t3i on t3 (expensivefunc(x));
analyze t3;
explain (costs off)
select * from
(select * from t3 a union all select * from t3 b) ss
join int4_tbl on f1 = expensivefunc(x);
QUERY PLAN
------------------------------------------------------------
Nested Loop
-> Seq Scan on int4_tbl
-> Append
-> Index Scan using t3i on t3 a
Index Cond: (expensivefunc(x) = int4_tbl.f1)
-> Index Scan using t3i on t3 b
Index Cond: (expensivefunc(x) = int4_tbl.f1)
(7 rows)
select * from
(select * from t3 a union all select * from t3 b) ss
join int4_tbl on f1 = expensivefunc(x);
x | f1
---+----
0 | 0
0 | 0
(2 rows)
drop table t3;
drop function expensivefunc(int);
Reference in New Issue View Git Blame Copy Permalink