2000-01-06 07:40:54 +01:00
|
|
|
--
|
2000-10-05 21:11:39 +02:00
|
|
|
-- UNION (also INTERSECT, EXCEPT)
|
2000-01-06 07:40:54 +01:00
|
|
|
--
|
|
|
|
-- Simple UNION constructs
|
2016-10-10 22:41:57 +02:00
|
|
|
SELECT 1 AS two UNION SELECT 2 ORDER BY 1;
|
2000-01-06 07:40:54 +01:00
|
|
|
two
|
|
|
|
-----
|
|
|
|
1
|
|
|
|
2
|
1998-05-29 15:22:42 +02:00
|
|
|
(2 rows)
|
|
|
|
|
2016-10-10 22:41:57 +02:00
|
|
|
SELECT 1 AS one UNION SELECT 1 ORDER BY 1;
|
2000-01-06 07:40:54 +01:00
|
|
|
one
|
|
|
|
-----
|
|
|
|
1
|
1998-05-29 15:22:42 +02:00
|
|
|
(1 row)
|
|
|
|
|
2000-01-06 07:40:54 +01:00
|
|
|
SELECT 1 AS two UNION ALL SELECT 2;
|
|
|
|
two
|
|
|
|
-----
|
|
|
|
1
|
|
|
|
2
|
1998-05-29 15:22:42 +02:00
|
|
|
(2 rows)
|
|
|
|
|
2000-01-06 07:40:54 +01:00
|
|
|
SELECT 1 AS two UNION ALL SELECT 1;
|
|
|
|
two
|
|
|
|
-----
|
|
|
|
1
|
|
|
|
1
|
1998-05-29 15:22:42 +02:00
|
|
|
(2 rows)
|
|
|
|
|
2016-10-10 22:41:57 +02:00
|
|
|
SELECT 1 AS three UNION SELECT 2 UNION SELECT 3 ORDER BY 1;
|
2000-01-06 07:40:54 +01:00
|
|
|
three
|
|
|
|
-------
|
|
|
|
1
|
|
|
|
2
|
|
|
|
3
|
1998-05-29 15:22:42 +02:00
|
|
|
(3 rows)
|
|
|
|
|
2016-10-10 22:41:57 +02:00
|
|
|
SELECT 1 AS two UNION SELECT 2 UNION SELECT 2 ORDER BY 1;
|
2000-01-06 07:40:54 +01:00
|
|
|
two
|
|
|
|
-----
|
|
|
|
1
|
|
|
|
2
|
1998-05-29 15:22:42 +02:00
|
|
|
(2 rows)
|
|
|
|
|
2016-10-10 22:41:57 +02:00
|
|
|
SELECT 1 AS three UNION SELECT 2 UNION ALL SELECT 2 ORDER BY 1;
|
2000-01-06 07:40:54 +01:00
|
|
|
three
|
|
|
|
-------
|
|
|
|
1
|
|
|
|
2
|
|
|
|
2
|
1998-05-29 15:22:42 +02:00
|
|
|
(3 rows)
|
|
|
|
|
2016-10-10 22:41:57 +02:00
|
|
|
SELECT 1.1 AS two UNION SELECT 2.2 ORDER BY 1;
|
2000-01-06 07:40:54 +01:00
|
|
|
two
|
|
|
|
-----
|
|
|
|
1.1
|
|
|
|
2.2
|
1998-05-29 15:22:42 +02:00
|
|
|
(2 rows)
|
|
|
|
|
2000-01-06 07:40:54 +01:00
|
|
|
-- Mixed types
|
2016-10-10 22:41:57 +02:00
|
|
|
SELECT 1.1 AS two UNION SELECT 2 ORDER BY 1;
|
2000-01-06 07:40:54 +01:00
|
|
|
two
|
|
|
|
-----
|
|
|
|
1.1
|
|
|
|
2
|
1998-05-29 15:22:42 +02:00
|
|
|
(2 rows)
|
|
|
|
|
2016-10-10 22:41:57 +02:00
|
|
|
SELECT 1 AS two UNION SELECT 2.2 ORDER BY 1;
|
2000-01-06 07:40:54 +01:00
|
|
|
two
|
|
|
|
-----
|
|
|
|
1
|
2000-10-05 21:11:39 +02:00
|
|
|
2.2
|
1998-05-29 15:22:42 +02:00
|
|
|
(2 rows)
|
|
|
|
|
2016-10-10 22:41:57 +02:00
|
|
|
SELECT 1 AS one UNION SELECT 1.0::float8 ORDER BY 1;
|
2000-01-06 07:40:54 +01:00
|
|
|
one
|
|
|
|
-----
|
|
|
|
1
|
1998-05-29 15:22:42 +02:00
|
|
|
(1 row)
|
|
|
|
|
2016-10-10 22:41:57 +02:00
|
|
|
SELECT 1.1 AS two UNION ALL SELECT 2 ORDER BY 1;
|
2000-01-06 07:40:54 +01:00
|
|
|
two
|
|
|
|
-----
|
|
|
|
1.1
|
|
|
|
2
|
1998-05-29 15:22:42 +02:00
|
|
|
(2 rows)
|
|
|
|
|
2016-10-10 22:41:57 +02:00
|
|
|
SELECT 1.0::float8 AS two UNION ALL SELECT 1 ORDER BY 1;
|
2000-01-06 07:40:54 +01:00
|
|
|
two
|
|
|
|
-----
|
2003-11-02 23:35:26 +01:00
|
|
|
1
|
2000-01-06 07:40:54 +01:00
|
|
|
1
|
1998-05-29 15:22:42 +02:00
|
|
|
(2 rows)
|
|
|
|
|
2016-10-10 22:41:57 +02:00
|
|
|
SELECT 1.1 AS three UNION SELECT 2 UNION SELECT 3 ORDER BY 1;
|
2000-01-06 07:40:54 +01:00
|
|
|
three
|
|
|
|
-------
|
2000-10-05 21:11:39 +02:00
|
|
|
1.1
|
2000-01-06 07:40:54 +01:00
|
|
|
2
|
|
|
|
3
|
1998-05-29 15:22:42 +02:00
|
|
|
(3 rows)
|
|
|
|
|
2008-08-07 03:11:52 +02:00
|
|
|
SELECT 1.1::float8 AS two UNION SELECT 2 UNION SELECT 2.0::float8 ORDER BY 1;
|
2000-01-06 07:40:54 +01:00
|
|
|
two
|
|
|
|
-----
|
2000-10-05 21:11:39 +02:00
|
|
|
1.1
|
2000-01-06 07:40:54 +01:00
|
|
|
2
|
1998-05-29 15:22:42 +02:00
|
|
|
(2 rows)
|
|
|
|
|
2016-10-10 22:41:57 +02:00
|
|
|
SELECT 1.1 AS three UNION SELECT 2 UNION ALL SELECT 2 ORDER BY 1;
|
2000-01-06 07:40:54 +01:00
|
|
|
three
|
|
|
|
-------
|
2000-10-05 21:11:39 +02:00
|
|
|
1.1
|
2000-01-06 07:40:54 +01:00
|
|
|
2
|
|
|
|
2
|
1998-05-29 15:22:42 +02:00
|
|
|
(3 rows)
|
|
|
|
|
2016-10-10 22:41:57 +02:00
|
|
|
SELECT 1.1 AS two UNION (SELECT 2 UNION ALL SELECT 2) ORDER BY 1;
|
2000-10-05 21:11:39 +02:00
|
|
|
two
|
|
|
|
-----
|
|
|
|
1.1
|
|
|
|
2
|
|
|
|
(2 rows)
|
|
|
|
|
2000-01-06 07:40:54 +01:00
|
|
|
--
|
|
|
|
-- Try testing from tables...
|
|
|
|
--
|
|
|
|
SELECT f1 AS five FROM FLOAT8_TBL
|
1998-05-29 15:22:42 +02:00
|
|
|
UNION
|
2008-08-07 03:11:52 +02:00
|
|
|
SELECT f1 FROM FLOAT8_TBL
|
|
|
|
ORDER BY 1;
|
2000-01-06 07:40:54 +01:00
|
|
|
five
|
|
|
|
-----------------------
|
|
|
|
-1.2345678901234e+200
|
|
|
|
-1004.3
|
|
|
|
-34.84
|
|
|
|
-1.2345678901234e-200
|
|
|
|
0
|
1998-05-29 15:22:42 +02:00
|
|
|
(5 rows)
|
|
|
|
|
2000-01-06 07:40:54 +01:00
|
|
|
SELECT f1 AS ten FROM FLOAT8_TBL
|
1998-05-29 15:22:42 +02:00
|
|
|
UNION ALL
|
|
|
|
SELECT f1 FROM FLOAT8_TBL;
|
2000-01-06 07:40:54 +01:00
|
|
|
ten
|
|
|
|
-----------------------
|
|
|
|
0
|
|
|
|
-34.84
|
|
|
|
-1004.3
|
|
|
|
-1.2345678901234e+200
|
|
|
|
-1.2345678901234e-200
|
|
|
|
0
|
|
|
|
-34.84
|
|
|
|
-1004.3
|
|
|
|
-1.2345678901234e+200
|
|
|
|
-1.2345678901234e-200
|
1998-05-29 15:22:42 +02:00
|
|
|
(10 rows)
|
|
|
|
|
2000-01-06 07:40:54 +01:00
|
|
|
SELECT f1 AS nine FROM FLOAT8_TBL
|
1998-05-29 15:22:42 +02:00
|
|
|
UNION
|
2008-08-07 03:11:52 +02:00
|
|
|
SELECT f1 FROM INT4_TBL
|
|
|
|
ORDER BY 1;
|
2000-01-06 07:40:54 +01:00
|
|
|
nine
|
|
|
|
-----------------------
|
|
|
|
-1.2345678901234e+200
|
|
|
|
-2147483647
|
|
|
|
-123456
|
|
|
|
-1004.3
|
|
|
|
-34.84
|
|
|
|
-1.2345678901234e-200
|
|
|
|
0
|
|
|
|
123456
|
|
|
|
2147483647
|
1998-05-29 15:22:42 +02:00
|
|
|
(9 rows)
|
|
|
|
|
2000-01-06 07:40:54 +01:00
|
|
|
SELECT f1 AS ten FROM FLOAT8_TBL
|
1998-05-29 15:22:42 +02:00
|
|
|
UNION ALL
|
|
|
|
SELECT f1 FROM INT4_TBL;
|
2000-01-06 07:40:54 +01:00
|
|
|
ten
|
|
|
|
-----------------------
|
|
|
|
0
|
|
|
|
-34.84
|
|
|
|
-1004.3
|
|
|
|
-1.2345678901234e+200
|
|
|
|
-1.2345678901234e-200
|
|
|
|
0
|
|
|
|
123456
|
|
|
|
-123456
|
|
|
|
2147483647
|
|
|
|
-2147483647
|
1998-05-29 15:22:42 +02:00
|
|
|
(10 rows)
|
|
|
|
|
2000-01-06 07:40:54 +01:00
|
|
|
SELECT f1 AS five FROM FLOAT8_TBL
|
1998-05-29 15:22:42 +02:00
|
|
|
WHERE f1 BETWEEN -1e6 AND 1e6
|
|
|
|
UNION
|
|
|
|
SELECT f1 FROM INT4_TBL
|
2016-10-10 22:41:57 +02:00
|
|
|
WHERE f1 BETWEEN 0 AND 1000000
|
|
|
|
ORDER BY 1;
|
2000-01-06 07:40:54 +01:00
|
|
|
five
|
|
|
|
-----------------------
|
|
|
|
-1004.3
|
|
|
|
-34.84
|
|
|
|
-1.2345678901234e-200
|
|
|
|
0
|
|
|
|
123456
|
1998-05-29 15:22:42 +02:00
|
|
|
(5 rows)
|
|
|
|
|
2003-05-26 02:11:29 +02:00
|
|
|
SELECT CAST(f1 AS char(4)) AS three FROM VARCHAR_TBL
|
1998-05-29 15:22:42 +02:00
|
|
|
UNION
|
2008-08-07 03:11:52 +02:00
|
|
|
SELECT f1 FROM CHAR_TBL
|
|
|
|
ORDER BY 1;
|
2003-05-26 02:11:29 +02:00
|
|
|
three
|
|
|
|
-------
|
2000-01-06 07:40:54 +01:00
|
|
|
a
|
|
|
|
ab
|
|
|
|
abcd
|
2003-05-26 02:11:29 +02:00
|
|
|
(3 rows)
|
1998-05-29 15:22:42 +02:00
|
|
|
|
2000-01-06 07:40:54 +01:00
|
|
|
SELECT f1 AS three FROM VARCHAR_TBL
|
1998-05-29 15:22:42 +02:00
|
|
|
UNION
|
2008-08-07 03:11:52 +02:00
|
|
|
SELECT CAST(f1 AS varchar) FROM CHAR_TBL
|
|
|
|
ORDER BY 1;
|
2000-01-06 07:40:54 +01:00
|
|
|
three
|
|
|
|
-------
|
|
|
|
a
|
|
|
|
ab
|
|
|
|
abcd
|
1998-05-29 15:22:42 +02:00
|
|
|
(3 rows)
|
|
|
|
|
2000-01-06 07:40:54 +01:00
|
|
|
SELECT f1 AS eight FROM VARCHAR_TBL
|
1998-05-29 15:22:42 +02:00
|
|
|
UNION ALL
|
|
|
|
SELECT f1 FROM CHAR_TBL;
|
2000-01-06 07:40:54 +01:00
|
|
|
eight
|
|
|
|
-------
|
|
|
|
a
|
|
|
|
ab
|
|
|
|
abcd
|
|
|
|
abcd
|
2003-05-26 02:11:29 +02:00
|
|
|
a
|
|
|
|
ab
|
2000-01-06 07:40:54 +01:00
|
|
|
abcd
|
|
|
|
abcd
|
1998-05-29 15:22:42 +02:00
|
|
|
(8 rows)
|
|
|
|
|
2000-01-06 07:40:54 +01:00
|
|
|
SELECT f1 AS five FROM TEXT_TBL
|
1998-05-29 15:22:42 +02:00
|
|
|
UNION
|
|
|
|
SELECT f1 FROM VARCHAR_TBL
|
|
|
|
UNION
|
2008-08-07 03:11:52 +02:00
|
|
|
SELECT TRIM(TRAILING FROM f1) FROM CHAR_TBL
|
|
|
|
ORDER BY 1;
|
2000-01-06 07:40:54 +01:00
|
|
|
five
|
|
|
|
-------------------
|
|
|
|
a
|
|
|
|
ab
|
|
|
|
abcd
|
|
|
|
doh!
|
|
|
|
hi de ho neighbor
|
1998-05-29 15:22:42 +02:00
|
|
|
(5 rows)
|
|
|
|
|
2000-10-05 21:11:39 +02:00
|
|
|
--
|
|
|
|
-- INTERSECT and EXCEPT
|
|
|
|
--
|
2016-10-10 22:41:57 +02:00
|
|
|
SELECT q2 FROM int8_tbl INTERSECT SELECT q1 FROM int8_tbl ORDER BY 1;
|
2000-10-05 21:11:39 +02:00
|
|
|
q2
|
|
|
|
------------------
|
2009-02-09 22:18:28 +01:00
|
|
|
123
|
2016-10-10 22:41:57 +02:00
|
|
|
4567890123456789
|
2000-10-05 21:11:39 +02:00
|
|
|
(2 rows)
|
|
|
|
|
2016-10-10 22:41:57 +02:00
|
|
|
SELECT q2 FROM int8_tbl INTERSECT ALL SELECT q1 FROM int8_tbl ORDER BY 1;
|
2000-10-05 21:11:39 +02:00
|
|
|
q2
|
|
|
|
------------------
|
2016-10-10 22:41:57 +02:00
|
|
|
123
|
2000-10-05 21:11:39 +02:00
|
|
|
4567890123456789
|
|
|
|
4567890123456789
|
|
|
|
(3 rows)
|
|
|
|
|
2008-08-07 05:04:04 +02:00
|
|
|
SELECT q2 FROM int8_tbl EXCEPT SELECT q1 FROM int8_tbl ORDER BY 1;
|
2000-10-05 21:11:39 +02:00
|
|
|
q2
|
|
|
|
-------------------
|
|
|
|
-4567890123456789
|
|
|
|
456
|
|
|
|
(2 rows)
|
|
|
|
|
2008-08-07 05:04:04 +02:00
|
|
|
SELECT q2 FROM int8_tbl EXCEPT ALL SELECT q1 FROM int8_tbl ORDER BY 1;
|
2000-10-05 21:11:39 +02:00
|
|
|
q2
|
|
|
|
-------------------
|
|
|
|
-4567890123456789
|
|
|
|
456
|
|
|
|
(2 rows)
|
|
|
|
|
2008-08-07 05:04:04 +02:00
|
|
|
SELECT q2 FROM int8_tbl EXCEPT ALL SELECT DISTINCT q1 FROM int8_tbl ORDER BY 1;
|
2000-10-05 21:11:39 +02:00
|
|
|
q2
|
|
|
|
-------------------
|
|
|
|
-4567890123456789
|
|
|
|
456
|
|
|
|
4567890123456789
|
|
|
|
(3 rows)
|
|
|
|
|
2016-10-10 22:41:57 +02:00
|
|
|
SELECT q1 FROM int8_tbl EXCEPT SELECT q2 FROM int8_tbl ORDER BY 1;
|
2000-11-09 03:47:49 +01:00
|
|
|
q1
|
|
|
|
----
|
|
|
|
(0 rows)
|
|
|
|
|
2016-10-10 22:41:57 +02:00
|
|
|
SELECT q1 FROM int8_tbl EXCEPT ALL SELECT q2 FROM int8_tbl ORDER BY 1;
|
2000-11-09 03:47:49 +01:00
|
|
|
q1
|
|
|
|
------------------
|
2009-02-09 22:18:28 +01:00
|
|
|
123
|
2016-10-10 22:41:57 +02:00
|
|
|
4567890123456789
|
2000-11-09 03:47:49 +01:00
|
|
|
(2 rows)
|
|
|
|
|
2016-10-10 22:41:57 +02:00
|
|
|
SELECT q1 FROM int8_tbl EXCEPT ALL SELECT DISTINCT q2 FROM int8_tbl ORDER BY 1;
|
2000-11-09 03:47:49 +01:00
|
|
|
q1
|
|
|
|
------------------
|
2016-10-10 22:41:57 +02:00
|
|
|
123
|
2000-11-09 03:47:49 +01:00
|
|
|
4567890123456789
|
|
|
|
4567890123456789
|
|
|
|
(3 rows)
|
|
|
|
|
2013-08-02 18:49:03 +02:00
|
|
|
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
|
2000-10-05 21:11:39 +02:00
|
|
|
--
|
|
|
|
-- Mixed types
|
|
|
|
--
|
2016-10-10 22:41:57 +02:00
|
|
|
SELECT f1 FROM float8_tbl INTERSECT SELECT f1 FROM int4_tbl ORDER BY 1;
|
2000-10-05 21:11:39 +02:00
|
|
|
f1
|
|
|
|
----
|
|
|
|
0
|
|
|
|
(1 row)
|
|
|
|
|
2008-08-07 05:04:04 +02:00
|
|
|
SELECT f1 FROM float8_tbl EXCEPT SELECT f1 FROM int4_tbl ORDER BY 1;
|
2000-10-05 21:11:39 +02:00
|
|
|
f1
|
|
|
|
-----------------------
|
|
|
|
-1.2345678901234e+200
|
|
|
|
-1004.3
|
|
|
|
-34.84
|
|
|
|
-1.2345678901234e-200
|
|
|
|
(4 rows)
|
|
|
|
|
2000-11-09 03:47:49 +01:00
|
|
|
--
|
|
|
|
-- Operator precedence and (((((extra))))) parentheses
|
|
|
|
--
|
2016-10-10 22:41:57 +02:00
|
|
|
SELECT q1 FROM int8_tbl INTERSECT SELECT q2 FROM int8_tbl UNION ALL SELECT q2 FROM int8_tbl ORDER BY 1;
|
2000-11-09 03:47:49 +01:00
|
|
|
q1
|
|
|
|
-------------------
|
2016-10-10 22:41:57 +02:00
|
|
|
-4567890123456789
|
|
|
|
123
|
2009-02-09 22:18:28 +01:00
|
|
|
123
|
2000-11-09 03:47:49 +01:00
|
|
|
456
|
|
|
|
4567890123456789
|
|
|
|
4567890123456789
|
2016-10-10 22:41:57 +02:00
|
|
|
4567890123456789
|
2000-11-09 03:47:49 +01:00
|
|
|
(7 rows)
|
|
|
|
|
2016-10-10 22:41:57 +02:00
|
|
|
SELECT q1 FROM int8_tbl INTERSECT (((SELECT q2 FROM int8_tbl UNION ALL SELECT q2 FROM int8_tbl))) ORDER BY 1;
|
2000-11-09 03:47:49 +01:00
|
|
|
q1
|
|
|
|
------------------
|
2009-02-09 22:18:28 +01:00
|
|
|
123
|
2016-10-10 22:41:57 +02:00
|
|
|
4567890123456789
|
2000-11-09 03:47:49 +01:00
|
|
|
(2 rows)
|
|
|
|
|
2016-10-10 22:41:57 +02:00
|
|
|
(((SELECT q1 FROM int8_tbl INTERSECT SELECT q2 FROM int8_tbl ORDER BY 1))) UNION ALL SELECT q2 FROM int8_tbl;
|
2000-11-09 03:47:49 +01:00
|
|
|
q1
|
|
|
|
-------------------
|
2009-02-09 22:18:28 +01:00
|
|
|
123
|
2016-10-10 22:41:57 +02:00
|
|
|
4567890123456789
|
2000-11-09 03:47:49 +01:00
|
|
|
456
|
|
|
|
4567890123456789
|
|
|
|
123
|
|
|
|
4567890123456789
|
|
|
|
-4567890123456789
|
|
|
|
(7 rows)
|
|
|
|
|
2008-08-07 05:04:04 +02:00
|
|
|
SELECT q1 FROM int8_tbl UNION ALL SELECT q2 FROM int8_tbl EXCEPT SELECT q1 FROM int8_tbl ORDER BY 1;
|
2000-11-09 03:47:49 +01:00
|
|
|
q1
|
|
|
|
-------------------
|
|
|
|
-4567890123456789
|
|
|
|
456
|
|
|
|
(2 rows)
|
|
|
|
|
2008-08-07 05:04:04 +02:00
|
|
|
SELECT q1 FROM int8_tbl UNION ALL (((SELECT q2 FROM int8_tbl EXCEPT SELECT q1 FROM int8_tbl ORDER BY 1)));
|
2000-11-09 03:47:49 +01:00
|
|
|
q1
|
|
|
|
-------------------
|
|
|
|
123
|
|
|
|
123
|
|
|
|
4567890123456789
|
|
|
|
4567890123456789
|
|
|
|
4567890123456789
|
|
|
|
-4567890123456789
|
|
|
|
456
|
|
|
|
(7 rows)
|
|
|
|
|
2008-08-07 05:04:04 +02:00
|
|
|
(((SELECT q1 FROM int8_tbl UNION ALL SELECT q2 FROM int8_tbl))) EXCEPT SELECT q1 FROM int8_tbl ORDER BY 1;
|
2000-11-09 03:47:49 +01:00
|
|
|
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;
|
2003-09-25 08:58:07 +02:00
|
|
|
ERROR: column "q2" does not exist
|
2006-03-14 23:48:25 +01:00
|
|
|
LINE 1: ... int8_tbl EXCEPT SELECT q2 FROM int8_tbl ORDER BY q2 LIMIT 1...
|
|
|
|
^
|
2012-08-08 01:02:54 +02:00
|
|
|
HINT: There is a column named "q2" in table "*SELECT* 2", but it cannot be referenced from this part of the query.
|
2000-11-09 03:47:49 +01:00
|
|
|
-- But this should work:
|
2016-10-10 22:41:57 +02:00
|
|
|
SELECT q1 FROM int8_tbl EXCEPT (((SELECT q2 FROM int8_tbl ORDER BY q2 LIMIT 1))) ORDER BY 1;
|
2000-11-09 03:47:49 +01:00
|
|
|
q1
|
|
|
|
------------------
|
2009-02-09 22:18:28 +01:00
|
|
|
123
|
2016-10-10 22:41:57 +02:00
|
|
|
4567890123456789
|
2000-11-09 03:47:49 +01:00
|
|
|
(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)
|
|
|
|
|
2009-12-16 23:24:13 +01:00
|
|
|
--
|
|
|
|
-- 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';
|
|
|
|
^
|
2012-01-29 22:31:23 +01:00
|
|
|
--
|
|
|
|
-- 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';
|
2013-03-14 18:42:51 +01:00
|
|
|
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)
|
2012-01-29 22:31:23 +01:00
|
|
|
|
|
|
|
explain (costs off)
|
|
|
|
SELECT * FROM
|
|
|
|
(SELECT a || b AS ab FROM t1
|
|
|
|
UNION
|
|
|
|
SELECT * FROM t2) t
|
|
|
|
WHERE ab = 'ab';
|
|
|
|
QUERY PLAN
|
|
|
|
---------------------------------------------------
|
|
|
|
HashAggregate
|
2013-12-12 17:24:38 +01:00
|
|
|
Group Key: ((t1.a || t1.b))
|
2012-01-29 22:31:23 +01:00
|
|
|
-> 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)
|
2013-12-12 17:24:38 +01:00
|
|
|
(7 rows)
|
2012-01-29 22:31:23 +01:00
|
|
|
|
2014-03-28 16:50:01 +01:00
|
|
|
--
|
|
|
|
-- 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)
|
|
|
|
|
2012-01-29 22:31:23 +01:00
|
|
|
reset enable_seqscan;
|
|
|
|
reset enable_indexscan;
|
|
|
|
reset enable_bitmapscan;
|
2014-06-26 19:40:50 +02:00
|
|
|
-- 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;
|
2014-03-28 16:50:01 +01:00
|
|
|
reset enable_indexonlyscan;
|
Revisit handling of UNION ALL subqueries with non-Var output columns.
In commit 57664ed25e5dea117158a2e663c29e60b3546e1c I tried to fix a bug
reported by Teodor Sigaev by making non-simple-Var output columns distinct
(by wrapping their expressions with dummy PlaceHolderVar nodes). This did
not work too well. Commit b28ffd0fcc583c1811e5295279e7d4366c3cae6c fixed
some ensuing problems with matching to child indexes, but per a recent
report from Claus Stadler, constraint exclusion of UNION ALL subqueries was
still broken, because constant-simplification didn't handle the injected
PlaceHolderVars well either. On reflection, the original patch was quite
misguided: there is no reason to expect that EquivalenceClass child members
will be distinct. So instead of trying to make them so, we should ensure
that we can cope with the situation when they're not.
Accordingly, this patch reverts the code changes in the above-mentioned
commits (though the regression test cases they added stay). Instead, I've
added assorted defenses to make sure that duplicate EC child members don't
cause any problems. Teodor's original problem ("MergeAppend child's
targetlist doesn't match MergeAppend") is addressed more directly by
revising prepare_sort_from_pathkeys to let the parent MergeAppend's sort
list guide creation of each child's sort list.
In passing, get rid of add_sort_column; as far as I can tell, testing for
duplicate sort keys at this stage is dead code. Certainly it doesn't
trigger often enough to be worth expending cycles on in ordinary queries.
And keeping the test would've greatly complicated the new logic in
prepare_sort_from_pathkeys, because comparing pathkey list entries against
a previous output array requires that we not skip any entries in the list.
Back-patch to 9.1, like the previous patches. The only known issue in
this area that wasn't caused by the ill-advised previous patches was the
MergeAppend planning failure, which of course is not relevant before 9.1.
It's possible that we need some of the new defenses against duplicate child
EC entries in older branches, but until there's some clear evidence of that
I'm going to refrain from back-patching further.
2012-03-16 18:11:12 +01:00
|
|
|
-- 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;
|
2013-03-14 18:42:51 +01:00
|
|
|
QUERY PLAN
|
|
|
|
---------------------------
|
|
|
|
Append
|
|
|
|
-> Seq Scan on tenk1 b
|
|
|
|
(2 rows)
|
Revisit handling of UNION ALL subqueries with non-Var output columns.
In commit 57664ed25e5dea117158a2e663c29e60b3546e1c I tried to fix a bug
reported by Teodor Sigaev by making non-simple-Var output columns distinct
(by wrapping their expressions with dummy PlaceHolderVar nodes). This did
not work too well. Commit b28ffd0fcc583c1811e5295279e7d4366c3cae6c fixed
some ensuing problems with matching to child indexes, but per a recent
report from Claus Stadler, constraint exclusion of UNION ALL subqueries was
still broken, because constant-simplification didn't handle the injected
PlaceHolderVars well either. On reflection, the original patch was quite
misguided: there is no reason to expect that EquivalenceClass child members
will be distinct. So instead of trying to make them so, we should ensure
that we can cope with the situation when they're not.
Accordingly, this patch reverts the code changes in the above-mentioned
commits (though the regression test cases they added stay). Instead, I've
added assorted defenses to make sure that duplicate EC child members don't
cause any problems. Teodor's original problem ("MergeAppend child's
targetlist doesn't match MergeAppend") is addressed more directly by
revising prepare_sort_from_pathkeys to let the parent MergeAppend's sort
list guide creation of each child's sort list.
In passing, get rid of add_sort_column; as far as I can tell, testing for
duplicate sort keys at this stage is dead code. Certainly it doesn't
trigger often enough to be worth expending cycles on in ordinary queries.
And keeping the test would've greatly complicated the new logic in
prepare_sort_from_pathkeys, because comparing pathkey list entries against
a previous output array requires that we not skip any entries in the list.
Back-patch to 9.1, like the previous patches. The only known issue in
this area that wasn't caused by the ill-advised previous patches was the
MergeAppend planning failure, which of course is not relevant before 9.1.
It's possible that we need some of the new defenses against duplicate child
EC entries in older branches, but until there's some clear evidence of that
I'm going to refrain from back-patching further.
2012-03-16 18:11:12 +01:00
|
|
|
|
2013-06-06 05:44:02 +02:00
|
|
|
-- 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
|
2016-10-10 22:41:57 +02:00
|
|
|
WHERE x < 4
|
|
|
|
ORDER BY x;
|
|
|
|
QUERY PLAN
|
|
|
|
--------------------------------------------------
|
|
|
|
Sort
|
|
|
|
Sort Key: (2)
|
|
|
|
-> Unique
|
|
|
|
-> Sort
|
|
|
|
Sort Key: (1), (2)
|
|
|
|
-> Append
|
|
|
|
-> Result
|
|
|
|
-> Result
|
|
|
|
One-Time Filter: false
|
|
|
|
(9 rows)
|
2013-06-06 05:44:02 +02:00
|
|
|
|
|
|
|
SELECT * FROM
|
|
|
|
(SELECT 1 AS t, 2 AS x
|
|
|
|
UNION
|
|
|
|
SELECT 2 AS t, 4 AS x) ss
|
2016-10-10 22:41:57 +02:00
|
|
|
WHERE x < 4
|
|
|
|
ORDER BY x;
|
2013-06-06 05:44:02 +02:00
|
|
|
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;
|
2013-12-12 17:24:38 +01:00
|
|
|
QUERY PLAN
|
|
|
|
--------------------------------------------------------
|
2013-06-06 05:44:02 +02:00
|
|
|
Sort
|
|
|
|
Sort Key: ss.x
|
|
|
|
-> Subquery Scan on ss
|
|
|
|
Filter: (ss.x < 4)
|
|
|
|
-> HashAggregate
|
2013-12-12 17:24:38 +01:00
|
|
|
Group Key: (1), (generate_series(1, 10))
|
2013-06-06 05:44:02 +02:00
|
|
|
-> Append
|
|
|
|
-> Result
|
|
|
|
-> Result
|
2013-12-12 17:24:38 +01:00
|
|
|
(9 rows)
|
2013-06-06 05:44:02 +02:00
|
|
|
|
|
|
|
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
|
2016-10-10 22:41:57 +02:00
|
|
|
WHERE x > 3
|
|
|
|
ORDER BY x;
|
|
|
|
QUERY PLAN
|
|
|
|
------------------------------------------------------------------------------------
|
|
|
|
Sort
|
|
|
|
Sort Key: ss.x
|
|
|
|
-> Subquery Scan on ss
|
|
|
|
Filter: (ss.x > 3)
|
|
|
|
-> Unique
|
|
|
|
-> Sort
|
|
|
|
Sort Key: (1), (((random() * '3'::double precision))::integer)
|
|
|
|
-> Append
|
|
|
|
-> Result
|
|
|
|
-> Result
|
|
|
|
(10 rows)
|
2013-06-06 05:44:02 +02:00
|
|
|
|
|
|
|
SELECT * FROM
|
|
|
|
(SELECT 1 AS t, (random()*3)::int AS x
|
|
|
|
UNION
|
|
|
|
SELECT 2 AS t, 4 AS x) ss
|
2016-10-10 22:41:57 +02:00
|
|
|
WHERE x > 3
|
|
|
|
ORDER BY x;
|
2013-06-06 05:44:02 +02:00
|
|
|
t | x
|
|
|
|
---+---
|
|
|
|
2 | 4
|
|
|
|
(1 row)
|
|
|
|
|
2013-07-08 04:37:24 +02:00
|
|
|
-- 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);
|