mirrors/postgres
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Verified output from new psql.

Browse Source 
Include a few new tests for datetime/timespan arithmetic.
This commit is contained in:
Thomas G. Lockhart 2000-01-05 06:06:23 +00:00
parent 24e8ca6ef9
commit d83105539a
21 changed files with 5366 additions and 4846 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

128
src/test/regress/expected/abstime.out
View File

@ -1,21 +1,35 @@
QUERY: CREATE TABLE ABSTIME_TBL (f1 abstime);
QUERY: INSERT INTO ABSTIME_TBL (f1) VALUES ('Jan 14, 1973 03:14:21');
QUERY: INSERT INTO ABSTIME_TBL (f1) VALUES ('Mon May 1 00:30:30 1995'::abstime);
QUERY: INSERT INTO ABSTIME_TBL (f1) VALUES ('epoch'::abstime);
QUERY: INSERT INTO ABSTIME_TBL (f1) VALUES ('current'::abstime);
QUERY: INSERT INTO ABSTIME_TBL (f1) VALUES ('infinity'::abstime);
QUERY: INSERT INTO ABSTIME_TBL (f1) VALUES ('-infinity'::abstime);
QUERY: INSERT INTO ABSTIME_TBL (f1) VALUES ('May 10, 1947 23:59:12');
QUERY: INSERT INTO ABSTIME_TBL (f1) VALUES ('Feb 35, 1946 10:00:00');
--
-- ABSTIME
-- testing built-in time type abstime
-- uses reltime and tinterval
--
--
-- timezones may vary based not only on location but the operating
-- system. the main correctness issue is that the OS may not get
-- daylight savings time right for times prior to Unix epoch (jan 1 1970).
--
CREATE TABLE ABSTIME_TBL (f1 abstime);
INSERT INTO ABSTIME_TBL (f1) VALUES ('Jan 14, 1973 03:14:21');
-- was INSERT INTO ABSTIME_TBL (f1) VALUES (abstime 'now'):
INSERT INTO ABSTIME_TBL (f1) VALUES (abstime 'Mon May 1 00:30:30 1995');
INSERT INTO ABSTIME_TBL (f1) VALUES (abstime 'epoch');
INSERT INTO ABSTIME_TBL (f1) VALUES (abstime 'current');
INSERT INTO ABSTIME_TBL (f1) VALUES (abstime 'infinity');
INSERT INTO ABSTIME_TBL (f1) VALUES (abstime '-infinity');
INSERT INTO ABSTIME_TBL (f1) VALUES (abstime 'May 10, 1947 23:59:12');
-- what happens if we specify slightly misformatted abstime?
INSERT INTO ABSTIME_TBL (f1) VALUES ('Feb 35, 1946 10:00:00');
ERROR: Bad abstime external representation 'Feb 35, 1946 10:00:00'
QUERY: INSERT INTO ABSTIME_TBL (f1) VALUES ('Feb 28, 1984 25:08:10');
INSERT INTO ABSTIME_TBL (f1) VALUES ('Feb 28, 1984 25:08:10');
ERROR: Bad abstime external representation 'Feb 28, 1984 25:08:10'
QUERY: INSERT INTO ABSTIME_TBL (f1) VALUES ('bad date format');
-- badly formatted abstimes: these should result in invalid abstimes
INSERT INTO ABSTIME_TBL (f1) VALUES ('bad date format');
ERROR: Bad abstime external representation 'bad date format'
QUERY: INSERT INTO ABSTIME_TBL (f1) VALUES ('Jun 10, 1843');
QUERY: SELECT '' AS eight, ABSTIME_TBL.*;
INSERT INTO ABSTIME_TBL (f1) VALUES ('Jun 10, 1843');
-- test abstime operators
SELECT '' AS eight, ABSTIME_TBL.*;
eight | f1
-----+----------------------------
-------+------------------------------
| Sun Jan 14 03:14:21 1973 PST
| Mon May 01 00:30:30 1995 PDT
| epoch
@ -26,10 +40,10 @@ eight|f1
| invalid
(8 rows)
QUERY: SELECT '' AS six, ABSTIME_TBL.*
WHERE ABSTIME_TBL.f1 < 'Jun 30, 2001'::abstime;
SELECT '' AS six, ABSTIME_TBL.*
WHERE ABSTIME_TBL.f1 < abstime 'Jun 30, 2001';
six | f1
---+----------------------------
-----+------------------------------
| Sun Jan 14 03:14:21 1973 PST
| Mon May 01 00:30:30 1995 PDT
| epoch
@ -38,10 +52,10 @@ six|f1
| Sat May 10 23:59:12 1947 PST
(6 rows)
QUERY: SELECT '' AS six, ABSTIME_TBL.*
WHERE ABSTIME_TBL.f1 > '-infinity'::abstime;
SELECT '' AS six, ABSTIME_TBL.*
WHERE ABSTIME_TBL.f1 > abstime '-infinity';
six | f1
---+----------------------------
-----+------------------------------
| Sun Jan 14 03:14:21 1973 PST
| Mon May 01 00:30:30 1995 PDT
| epoch
@ -50,10 +64,10 @@ six|f1
| Sat May 10 23:59:12 1947 PST
(6 rows)
QUERY: SELECT '' AS six, ABSTIME_TBL.*
WHERE 'May 10, 1947 23:59:12'::abstime <> ABSTIME_TBL.f1;
SELECT '' AS six, ABSTIME_TBL.*
WHERE abstime 'May 10, 1947 23:59:12' <> ABSTIME_TBL.f1;
six | f1
---+----------------------------
-----+------------------------------
| Sun Jan 14 03:14:21 1973 PST
| Mon May 01 00:30:30 1995 PDT
| epoch
@ -62,89 +76,91 @@ six|f1
| -infinity
(6 rows)
QUERY: SELECT '' AS one, ABSTIME_TBL.*
WHERE 'current'::abstime = ABSTIME_TBL.f1;
SELECT '' AS one, ABSTIME_TBL.*
WHERE abstime 'current' = ABSTIME_TBL.f1;
one | f1
---+-------
-----+---------
| current
(1 row)
QUERY: SELECT '' AS three, ABSTIME_TBL.*
WHERE 'epoch'::abstime >= ABSTIME_TBL.f1;
SELECT '' AS three, ABSTIME_TBL.*
WHERE abstime 'epoch' >= ABSTIME_TBL.f1;
three | f1
-----+----------------------------
-------+------------------------------
| epoch
| -infinity
| Sat May 10 23:59:12 1947 PST
(3 rows)
QUERY: SELECT '' AS four, ABSTIME_TBL.*
WHERE ABSTIME_TBL.f1 <= 'Jan 14, 1973 03:14:21'::abstime;
SELECT '' AS four, ABSTIME_TBL.*
WHERE ABSTIME_TBL.f1 <= abstime 'Jan 14, 1973 03:14:21';
four | f1
----+----------------------------
------+------------------------------
| Sun Jan 14 03:14:21 1973 PST
| epoch
| -infinity
| Sat May 10 23:59:12 1947 PST
(4 rows)
QUERY: SELECT '' AS four, ABSTIME_TBL.*
SELECT '' AS four, ABSTIME_TBL.*
WHERE ABSTIME_TBL.f1 <?>
'["Apr 1 1950 00:00:00" "Dec 30 1999 23:00:00"]'::tinterval;
tinterval '["Apr 1 1950 00:00:00" "Dec 30 1999 23:00:00"]';
four | f1
----+----------------------------
------+------------------------------
| Sun Jan 14 03:14:21 1973 PST
| Mon May 01 00:30:30 1995 PDT
| epoch
|current
(4 rows)
(3 rows)
QUERY: SELECT '' AS three, ABSTIME_TBL.*
WHERE (ABSTIME_TBL.f1 + '@ 3 year'::reltime)
< 'Jan 14 14:00:00 1977'::abstime;
-- these four queries should return the same answer
-- the "infinity" and "-infinity" tuples in ABSTIME_TBL cannot be added and
-- therefore, should not show up in the results.
SELECT '' AS three, ABSTIME_TBL.*
WHERE (ABSTIME_TBL.f1 + reltime '@ 3 year') -- +3 years
< abstime 'Jan 14 14:00:00 1977';
three | f1
-----+----------------------------
-------+------------------------------
| Sun Jan 14 03:14:21 1973 PST
| epoch
| Sat May 10 23:59:12 1947 PST
(3 rows)
QUERY: SELECT '' AS three, ABSTIME_TBL.*
WHERE (ABSTIME_TBL.f1 + '@ 3 year ago'::reltime)
< 'Jan 14 14:00:00 1971'::abstime;
SELECT '' AS three, ABSTIME_TBL.*
WHERE (ABSTIME_TBL.f1 + reltime '@ 3 year ago') -- -3 years
< abstime 'Jan 14 14:00:00 1971';
three | f1
-----+----------------------------
-------+------------------------------
| Sun Jan 14 03:14:21 1973 PST
| epoch
| Sat May 10 23:59:12 1947 PST
(3 rows)
QUERY: SELECT '' AS three, ABSTIME_TBL.*
WHERE (ABSTIME_TBL.f1 - '@ 3 year'::reltime)
< 'Jan 14 14:00:00 1971'::abstime;
SELECT '' AS three, ABSTIME_TBL.*
WHERE (ABSTIME_TBL.f1 - reltime '@ 3 year') -- -(+3) years
< abstime 'Jan 14 14:00:00 1971';
three | f1
-----+----------------------------
-------+------------------------------
| Sun Jan 14 03:14:21 1973 PST
| epoch
| Sat May 10 23:59:12 1947 PST
(3 rows)
QUERY: SELECT '' AS three, ABSTIME_TBL.*
WHERE (ABSTIME_TBL.f1 - '@ 3 year ago'::reltime)
< 'Jan 14 14:00:00 1977'::abstime;
SELECT '' AS three, ABSTIME_TBL.*
WHERE (ABSTIME_TBL.f1 - reltime '@ 3 year ago') -- -(-3) years
< abstime 'Jan 14 14:00:00 1977';
three | f1
-----+----------------------------
-------+------------------------------
| Sun Jan 14 03:14:21 1973 PST
| epoch
| Sat May 10 23:59:12 1947 PST
(3 rows)
QUERY: SELECT '' AS ten, ABSTIME_TBL.f1 AS abstime, RELTIME_TBL.f1 AS reltime
SELECT '' AS ten, ABSTIME_TBL.f1 AS abstime, RELTIME_TBL.f1 AS reltime
WHERE (ABSTIME_TBL.f1 + RELTIME_TBL.f1)
< 'Jan 14 14:00:00 1971'::abstime
< abstime 'Jan 14 14:00:00 1971'
ORDER BY abstime, reltime;
ten | abstime | reltime
---+----------------------------+-------------
-----+------------------------------+---------------
| Sat May 10 23:59:12 1947 PST | @ 14 secs ago
| Sat May 10 23:59:12 1947 PST | @ 1 min
| Sat May 10 23:59:12 1947 PST | @ 5 hours

151
src/test/regress/expected/box.out
View File

@ -1,175 +1,210 @@
QUERY: CREATE TABLE BOX_TBL (f1 box);
QUERY: INSERT INTO BOX_TBL (f1) VALUES ('(2.0,2.0,0.0,0.0)');
QUERY: INSERT INTO BOX_TBL (f1) VALUES ('(1.0,1.0,3.0,3.0)');
QUERY: INSERT INTO BOX_TBL (f1) VALUES ('(2.5, 2.5, 2.5,3.5)');
QUERY: INSERT INTO BOX_TBL (f1) VALUES ('(3.0, 3.0,3.0,3.0)');
QUERY: INSERT INTO BOX_TBL (f1) VALUES ('(2.3, 4.5)');
--
-- BOX
--
--
-- box logic
-- o
-- 3 o--|X
-- | o|
-- 2 +-+-+ |
-- | | | |
-- 1 | o-+-o
-- | |
-- 0 +---+
--
-- 0 1 2 3
--
-- boxes are specified by two points, given by four floats x1,y1,x2,y2
CREATE TABLE BOX_TBL (f1 box);
INSERT INTO BOX_TBL (f1) VALUES ('(2.0,2.0,0.0,0.0)');
INSERT INTO BOX_TBL (f1) VALUES ('(1.0,1.0,3.0,3.0)');
-- degenerate cases where the box is a line or a point
-- note that lines and points boxes all have zero area
INSERT INTO BOX_TBL (f1) VALUES ('(2.5, 2.5, 2.5,3.5)');
INSERT INTO BOX_TBL (f1) VALUES ('(3.0, 3.0,3.0,3.0)');
-- badly formatted box inputs
INSERT INTO BOX_TBL (f1) VALUES ('(2.3, 4.5)');
ERROR: Bad box external representation '(2.3, 4.5)'
QUERY: INSERT INTO BOX_TBL (f1) VALUES ('asdfasdf(ad');
INSERT INTO BOX_TBL (f1) VALUES ('asdfasdf(ad');
ERROR: Bad box external representation 'asdfasdf(ad'
QUERY: SELECT '' AS four, BOX_TBL.*;
SELECT '' AS four, BOX_TBL.*;
four | f1
----+-------------------
------+---------------------
| (2,2),(0,0)
| (3,3),(1,1)
| (2.5,3.5),(2.5,2.5)
| (3,3),(3,3)
(4 rows)
QUERY: SELECT '' AS four, b.*, box_area(b.f1) as barea
SELECT '' AS four, b.*, box_area(b.f1) as barea
FROM BOX_TBL b;
four | f1 | barea
----+-------------------+-----
------+---------------------+-------
| (2,2),(0,0) | 4
| (3,3),(1,1) | 4
| (2.5,3.5),(2.5,2.5) | 0
| (3,3),(3,3) | 0
(4 rows)
QUERY: SELECT '' AS three, b.f1
-- overlap
SELECT '' AS three, b.f1
FROM BOX_TBL b
WHERE b.f1 && '(2.5,2.5,1.0,1.0)'::box;
WHERE b.f1 && box '(2.5,2.5,1.0,1.0)';
three | f1
-----+-------------------
-------+---------------------
| (2,2),(0,0)
| (3,3),(1,1)
| (2.5,3.5),(2.5,2.5)
(3 rows)
QUERY: SELECT '' AS two, b1.*
-- left-or-overlap (x only)
SELECT '' AS two, b1.*
FROM BOX_TBL b1
WHERE b1.f1 &< '(2.0,2.0,2.5,2.5)'::box;
WHERE b1.f1 &< box '(2.0,2.0,2.5,2.5)';
two | f1
---+-------------------
-----+---------------------
| (2,2),(0,0)
| (2.5,3.5),(2.5,2.5)
(2 rows)
QUERY: SELECT '' AS two, b1.*
-- right-or-overlap (x only)
SELECT '' AS two, b1.*
FROM BOX_TBL b1
WHERE b1.f1 &> '(2.0,2.0,2.5,2.5)'::box;
WHERE b1.f1 &> box '(2.0,2.0,2.5,2.5)';
two | f1
---+-------------------
-----+---------------------
| (2.5,3.5),(2.5,2.5)
| (3,3),(3,3)
(2 rows)
QUERY: SELECT '' AS two, b.f1
-- left of
SELECT '' AS two, b.f1
FROM BOX_TBL b
WHERE b.f1 << '(3.0,3.0,5.0,5.0)'::box;
WHERE b.f1 << box '(3.0,3.0,5.0,5.0)';
two | f1
---+-------------------
-----+---------------------
| (2,2),(0,0)
| (2.5,3.5),(2.5,2.5)
(2 rows)
QUERY: SELECT '' AS four, b.f1
-- area <=
SELECT '' AS four, b.f1
FROM BOX_TBL b
WHERE b.f1 <= '(3.0,3.0,5.0,5.0)'::box;
WHERE b.f1 <= box '(3.0,3.0,5.0,5.0)';
four | f1
----+-------------------
------+---------------------
| (2,2),(0,0)
| (3,3),(1,1)
| (2.5,3.5),(2.5,2.5)
| (3,3),(3,3)
(4 rows)
QUERY: SELECT '' AS two, b.f1
-- area <
SELECT '' AS two, b.f1
FROM BOX_TBL b
WHERE b.f1 < '(3.0,3.0,5.0,5.0)'::box;
WHERE b.f1 < box '(3.0,3.0,5.0,5.0)';
two | f1
---+-------------------
-----+---------------------
| (2.5,3.5),(2.5,2.5)
| (3,3),(3,3)
(2 rows)
QUERY: SELECT '' AS two, b.f1
-- area =
SELECT '' AS two, b.f1
FROM BOX_TBL b
WHERE b.f1 = '(3.0,3.0,5.0,5.0)'::box;
WHERE b.f1 = box '(3.0,3.0,5.0,5.0)';
two | f1
---+-----------
-----+-------------
| (2,2),(0,0)
| (3,3),(1,1)
(2 rows)
QUERY: SELECT '' AS two, b.f1
FROM BOX_TBL b
WHERE b.f1 > '(3.5,3.0,4.5,3.0)'::box;
-- area >
SELECT '' AS two, b.f1
FROM BOX_TBL b -- zero area
WHERE b.f1 > box '(3.5,3.0,4.5,3.0)';
two | f1
---+-----------
-----+-------------
| (2,2),(0,0)
| (3,3),(1,1)
(2 rows)
QUERY: SELECT '' AS four, b.f1
FROM BOX_TBL b
WHERE b.f1 >= '(3.5,3.0,4.5,3.0)'::box;
-- area >=
SELECT '' AS four, b.f1
FROM BOX_TBL b -- zero area
WHERE b.f1 >= box '(3.5,3.0,4.5,3.0)';
four | f1
----+-------------------
------+---------------------
| (2,2),(0,0)
| (3,3),(1,1)
| (2.5,3.5),(2.5,2.5)
| (3,3),(3,3)
(4 rows)
QUERY: SELECT '' AS two, b.f1
-- right of
SELECT '' AS two, b.f1
FROM BOX_TBL b
WHERE '(3.0,3.0,5.0,5.0)'::box >> b.f1;
WHERE box '(3.0,3.0,5.0,5.0)' >> b.f1;
two | f1
---+-------------------
-----+---------------------
| (2,2),(0,0)
| (2.5,3.5),(2.5,2.5)
(2 rows)
QUERY: SELECT '' AS three, b.f1
-- contained in
SELECT '' AS three, b.f1
FROM BOX_TBL b
WHERE b.f1 @ '(0,0,3,3)'::box;
WHERE b.f1 @ box '(0,0,3,3)';
three | f1
-----+-----------
-------+-------------
| (2,2),(0,0)
| (3,3),(1,1)
| (3,3),(3,3)
(3 rows)
QUERY: SELECT '' AS three, b.f1
-- contains
SELECT '' AS three, b.f1
FROM BOX_TBL b
WHERE '(0,0,3,3)'::box ~ b.f1;
WHERE box '(0,0,3,3)' ~ b.f1;
three | f1
-----+-----------
-------+-------------
| (2,2),(0,0)
| (3,3),(1,1)
| (3,3),(3,3)
(3 rows)
QUERY: SELECT '' AS one, b.f1
-- box equality
SELECT '' AS one, b.f1
FROM BOX_TBL b
WHERE '(1,1,3,3)'::box ~= b.f1;
WHERE box '(1,1,3,3)' ~= b.f1;
one | f1
---+-----------
-----+-------------
| (3,3),(1,1)
(1 row)
QUERY: SELECT '' AS four, @@(b1.f1) AS p
-- center of box, left unary operator
SELECT '' AS four, @@(b1.f1) AS p
FROM BOX_TBL b1;
four | p
----+-------
------+---------
| (1,1)
| (2,2)
| (2.5,3)
| (3,3)
(4 rows)
QUERY: SELECT '' AS one, b1.*, b2.*
-- wholly-contained
SELECT '' AS one, b1.*, b2.*
FROM BOX_TBL b1, BOX_TBL b2
WHERE b1.f1 ~ b2.f1 and not b1.f1 ~= b2.f1;
one | f1 | f1
---+-----------+-----------
-----+-------------+-------------
| (3,3),(1,1) | (3,3),(3,3)
(1 row)
QUERY: SELECT '' AS four, height(f1), width(f1) FROM BOX_TBL;
SELECT '' AS four, height(f1), width(f1) FROM BOX_TBL;
four | height | width
----+------+-----
------+--------+-------
| 2 | 2
| 2 | 2
| 1 | 0

52
src/test/regress/expected/circle.out
View File

@ -1,19 +1,23 @@
QUERY: CREATE TABLE CIRCLE_TBL (f1 circle);
QUERY: INSERT INTO CIRCLE_TBL VALUES ('<(0,0),3>');
QUERY: INSERT INTO CIRCLE_TBL VALUES ('<(1,2),100>');
QUERY: INSERT INTO CIRCLE_TBL VALUES ('1,3,5');
QUERY: INSERT INTO CIRCLE_TBL VALUES ('((1,2),3)');
QUERY: INSERT INTO CIRCLE_TBL VALUES ('<(100,200),10>');
QUERY: INSERT INTO CIRCLE_TBL VALUES ('<(100,0),100>');
QUERY: INSERT INTO CIRCLE_TBL VALUES ('<(-100,0),-100>');
--
-- CIRCLE
--
CREATE TABLE CIRCLE_TBL (f1 circle);
INSERT INTO CIRCLE_TBL VALUES ('<(0,0),3>');
INSERT INTO CIRCLE_TBL VALUES ('<(1,2),100>');
INSERT INTO CIRCLE_TBL VALUES ('1,3,5');
INSERT INTO CIRCLE_TBL VALUES ('((1,2),3)');
INSERT INTO CIRCLE_TBL VALUES ('<(100,200),10>');
INSERT INTO CIRCLE_TBL VALUES ('<(100,0),100>');
-- bad values
INSERT INTO CIRCLE_TBL VALUES ('<(-100,0),-100>');
ERROR: Bad circle external representation '<(-100,0),-100>'
QUERY: INSERT INTO CIRCLE_TBL VALUES ('1abc,3,5');
INSERT INTO CIRCLE_TBL VALUES ('1abc,3,5');
ERROR: Bad circle external representation '1abc,3,5'
QUERY: INSERT INTO CIRCLE_TBL VALUES ('(3,(1,2),3)');
INSERT INTO CIRCLE_TBL VALUES ('(3,(1,2),3)');
ERROR: Bad circle external representation '(3,(1,2),3)'
QUERY: SELECT * FROM CIRCLE_TBL;
SELECT * FROM CIRCLE_TBL;
f1
--------------
----------------
<(0,0),3>
<(1,2),100>
<(1,3),5>
@ -22,10 +26,10 @@ f1
<(100,0),100>
(6 rows)
QUERY: SELECT '' AS six, center(f1) AS center
SELECT '' AS six, center(f1) AS center
FROM CIRCLE_TBL;
six | center
---+---------
-----+-----------
| (0,0)
| (1,2)
| (1,3)
@ -34,10 +38,10 @@ six|center
| (100,0)
(6 rows)
QUERY: SELECT '' AS six, radius(f1) AS radius
SELECT '' AS six, radius(f1) AS radius
FROM CIRCLE_TBL;
six | radius
---+------
-----+--------
| 3
| 100
| 5
@ -46,10 +50,10 @@ six|radius
| 100
(6 rows)
QUERY: SELECT '' AS six, diameter(f1) AS diameter
SELECT '' AS six, diameter(f1) AS diameter
FROM CIRCLE_TBL;
six | diameter
---+--------
-----+----------
| 6
| 200
| 10
@ -58,28 +62,28 @@ six|diameter
| 200
(6 rows)
QUERY: SELECT '' AS two, f1 FROM CIRCLE_TBL WHERE radius(f1) < 5;
SELECT '' AS two, f1 FROM CIRCLE_TBL WHERE radius(f1) < 5;
two | f1
---+---------
-----+-----------
| <(0,0),3>
| <(1,2),3>
(2 rows)
QUERY: SELECT '' AS four, f1 FROM CIRCLE_TBL WHERE diameter(f1) >= 10;
SELECT '' AS four, f1 FROM CIRCLE_TBL WHERE diameter(f1) >= 10;
four | f1
----+--------------
------+----------------
| <(1,2),100>
| <(1,3),5>
| <(100,200),10>
| <(100,0),100>
(4 rows)
QUERY: SELECT '' as five, c1.f1 AS one, c2.f1 AS two, (c1.f1 <-> c2.f1) AS distance
SELECT '' as five, c1.f1 AS one, c2.f1 AS two, (c1.f1 <-> c2.f1) AS distance
FROM CIRCLE_TBL c1, CIRCLE_TBL c2
WHERE (c1.f1 < c2.f1) AND ((c1.f1 <-> c2.f1) > 0)
ORDER BY distance, one, two;
five | one | two | distance
----+--------------+--------------+----------------
------+----------------+----------------+------------------
| <(100,200),10> | <(100,0),100> | 90
| <(100,200),10> | <(1,2),100> | 111.370729772479
| <(1,3),5> | <(100,200),10> | 205.476756144497

22
src/test/regress/expected/comments.out
View File

@ -1,35 +1,37 @@
QUERY: SELECT 'trailing' AS first;
--
-- COMMENTS
--
SELECT 'trailing' AS first; -- trailing single line
first
--------
----------
trailing
(1 row)
QUERY:
SELECT /* embedded single line */ 'embedded' AS second;
second
--------
----------
embedded
(1 row)
QUERY: SELECT /* both embedded and trailing single line */ 'both' AS third;
SELECT /* both embedded and trailing single line */ 'both' AS third; -- trailing single line
third
-----
-------
both
(1 row)
QUERY:
SELECT 'before multi-line' AS fourth;
fourth
-----------------
-------------------
before multi-line
(1 row)
QUERY: /* This is an example of SQL which should not execute:
/* This is an example of SQL which should not execute:
* select 'multi-line';
*/
SELECT 'after multi-line' AS fifth;
fifth
----------------
------------------
after multi-line
(1 row)
/* and this is the end of the file */

286
src/test/regress/expected/datetime.out
View File

@ -1,165 +1,179 @@
QUERY: SELECT ('today'::datetime = ('yesterday'::datetime + '1 day'::timespan)) as "True";
--
-- DATETIME
--
-- Shorthand values
-- Not directly usable for regression testing since these are not constants.
-- So, just try to test parser and hope for the best - tgl 97/04/26
SELECT (datetime 'today' = (datetime 'yesterday' + timespan '1 day')) as "True";
True
----
------
t
(1 row)
QUERY: SELECT ('today'::datetime = ('tomorrow'::datetime - '1 day'::timespan)) as "True";
SELECT (datetime 'today' = (datetime 'tomorrow' - timespan '1 day')) as "True";
True
----
------
t
(1 row)
QUERY: SELECT ('tomorrow'::datetime = ('yesterday'::datetime + '2 days'::timespan)) as "True";
SELECT (datetime 'tomorrow' = (datetime 'yesterday' + timespan '2 days')) as "True";
True
----
------
t
(1 row)
QUERY: SELECT ('current'::datetime = 'now'::datetime) as "True";
SELECT (datetime 'current' = 'now') as "True";
True
----
------
t
(1 row)
QUERY: SELECT ('now'::datetime - 'current'::datetime) AS "ZeroSecs";
SELECT (datetime 'now' - 'current') AS "ZeroSecs";
ZeroSecs
--------
----------
@ 0
(1 row)
QUERY: SET DateStyle = 'Postgres,noneuropean';
QUERY: SELECT datetime('1994-01-01', '11:00') AS "Jan_01_1994_11am";
SET DateStyle = 'Postgres,noneuropean';
SELECT datetime('1994-01-01', '11:00') AS "Jan_01_1994_11am";
Jan_01_1994_11am
----------------------------
------------------------------
Sat Jan 01 11:00:00 1994 PST
(1 row)
QUERY: CREATE TABLE DATETIME_TBL( d1 datetime);
QUERY: INSERT INTO DATETIME_TBL VALUES ('current');
QUERY: INSERT INTO DATETIME_TBL VALUES ('today');
QUERY: INSERT INTO DATETIME_TBL VALUES ('yesterday');
QUERY: INSERT INTO DATETIME_TBL VALUES ('tomorrow');
QUERY: INSERT INTO DATETIME_TBL VALUES ('tomorrow EST');
QUERY: INSERT INTO DATETIME_TBL VALUES ('tomorrow zulu');
QUERY: SELECT count(*) AS one FROM DATETIME_TBL WHERE d1 = 'today'::datetime;
CREATE TABLE DATETIME_TBL( d1 datetime);
INSERT INTO DATETIME_TBL VALUES ('current');
INSERT INTO DATETIME_TBL VALUES ('today');
INSERT INTO DATETIME_TBL VALUES ('yesterday');
INSERT INTO DATETIME_TBL VALUES ('tomorrow');
INSERT INTO DATETIME_TBL VALUES ('tomorrow EST');
INSERT INTO DATETIME_TBL VALUES ('tomorrow zulu');
SELECT count(*) AS one FROM DATETIME_TBL WHERE d1 = datetime 'today';
one
---
-----
1
(1 row)
QUERY: SELECT count(*) AS one FROM DATETIME_TBL WHERE d1 = 'tomorrow'::datetime;
SELECT count(*) AS one FROM DATETIME_TBL WHERE d1 = datetime 'tomorrow';
one
---
-----
1
(1 row)
QUERY: SELECT count(*) AS one FROM DATETIME_TBL WHERE d1 = 'yesterday'::datetime;
SELECT count(*) AS one FROM DATETIME_TBL WHERE d1 = datetime 'yesterday';
one
---
-----
1
(1 row)
QUERY: SELECT count(*) AS one FROM DATETIME_TBL WHERE d1 = 'today'::datetime + '1 day'::timespan;
SELECT count(*) AS one FROM DATETIME_TBL WHERE d1 = datetime 'today' + timespan '1 day';
one
---
-----
1
(1 row)
QUERY: SELECT count(*) AS one FROM DATETIME_TBL WHERE d1 = 'today'::datetime - '1 day'::timespan;
SELECT count(*) AS one FROM DATETIME_TBL WHERE d1 = datetime 'today' - timespan '1 day';
one
---
-----
1
(1 row)
QUERY: SELECT count(*) AS one FROM DATETIME_TBL WHERE d1 = 'now'::datetime;
SELECT count(*) AS one FROM DATETIME_TBL WHERE d1 = datetime 'now';
one
---
-----
1
(1 row)
QUERY: DELETE FROM DATETIME_TBL;
QUERY: INSERT INTO DATETIME_TBL VALUES ('current');
QUERY: BEGIN;
QUERY: INSERT INTO DATETIME_TBL VALUES ('now');
QUERY: SELECT count(*) AS two FROM DATETIME_TBL WHERE d1 = 'now'::datetime;
DELETE FROM DATETIME_TBL;
-- verify uniform transaction time within transaction block
INSERT INTO DATETIME_TBL VALUES ('current');
BEGIN;
INSERT INTO DATETIME_TBL VALUES ('now');
SELECT count(*) AS two FROM DATETIME_TBL WHERE d1 = datetime 'now';
two
---
-----
2
(1 row)
QUERY: END;
QUERY: DELETE FROM DATETIME_TBL;
QUERY: INSERT INTO DATETIME_TBL VALUES ('invalid');
QUERY: INSERT INTO DATETIME_TBL VALUES ('-infinity');
QUERY: INSERT INTO DATETIME_TBL VALUES ('infinity');
QUERY: INSERT INTO DATETIME_TBL VALUES ('epoch');
QUERY: INSERT INTO DATETIME_TBL VALUES ('Mon Feb 10 17:32:01 1997 PST');
QUERY: INSERT INTO DATETIME_TBL VALUES ('Invalid Abstime');
QUERY: INSERT INTO DATETIME_TBL VALUES ('Undefined Abstime');
QUERY: INSERT INTO DATETIME_TBL VALUES ('Mon Feb 10 17:32:01.000001 1997 PST');
QUERY: INSERT INTO DATETIME_TBL VALUES ('Mon Feb 10 17:32:01.999999 1997 PST');
QUERY: INSERT INTO DATETIME_TBL VALUES ('Mon Feb 10 17:32:01.4 1997 PST');
QUERY: INSERT INTO DATETIME_TBL VALUES ('Mon Feb 10 17:32:01.5 1997 PST');
QUERY: INSERT INTO DATETIME_TBL VALUES ('Mon Feb 10 17:32:01.6 1997 PST');
QUERY: INSERT INTO DATETIME_TBL VALUES ('1997-01-02');
QUERY: INSERT INTO DATETIME_TBL VALUES ('1997-01-02 03:04:05');
QUERY: INSERT INTO DATETIME_TBL VALUES ('1997-02-10 17:32:01-08');
QUERY: INSERT INTO DATETIME_TBL VALUES ('1997-02-10 17:32:01-0800');
QUERY: INSERT INTO DATETIME_TBL VALUES ('1997-02-10 17:32:01 -08:00');
QUERY: INSERT INTO DATETIME_TBL VALUES ('19970210 173201 -0800');
QUERY: INSERT INTO DATETIME_TBL VALUES ('1997-06-10 17:32:01 -07:00');
QUERY: INSERT INTO DATETIME_TBL VALUES ('Feb 10 17:32:01 1997 -0800');
QUERY: INSERT INTO DATETIME_TBL VALUES ('Feb 10 17:32:01 1997');
QUERY: INSERT INTO DATETIME_TBL VALUES ('Feb 10 5:32PM 1997');
QUERY: INSERT INTO DATETIME_TBL VALUES ('1997/02/10 17:32:01-0800');
QUERY: INSERT INTO DATETIME_TBL VALUES ('1997-02-10 17:32:01 PST');
QUERY: INSERT INTO DATETIME_TBL VALUES ('Feb-10-1997 17:32:01 PST');
QUERY: INSERT INTO DATETIME_TBL VALUES ('02-10-1997 17:32:01 PST');
QUERY: INSERT INTO DATETIME_TBL VALUES ('19970210 173201 PST');
QUERY: INSERT INTO DATETIME_TBL VALUES ('97FEB10 5:32:01PM UTC');
QUERY: INSERT INTO DATETIME_TBL VALUES ('97/02/10 17:32:01 UTC');
QUERY: INSERT INTO DATETIME_TBL VALUES ('97.041 17:32:01 UTC');
QUERY: INSERT INTO DATETIME_TBL VALUES ('1997-06-10 18:32:01 PDT');
QUERY: INSERT INTO DATETIME_TBL VALUES ('Feb 10 17:32:01 1997');
QUERY: INSERT INTO DATETIME_TBL VALUES ('Feb 11 17:32:01 1997');
QUERY: INSERT INTO DATETIME_TBL VALUES ('Feb 12 17:32:01 1997');
QUERY: INSERT INTO DATETIME_TBL VALUES ('Feb 13 17:32:01 1997');
QUERY: INSERT INTO DATETIME_TBL VALUES ('Feb 14 17:32:01 1997');
QUERY: INSERT INTO DATETIME_TBL VALUES ('Feb 15 17:32:01 1997');
QUERY: INSERT INTO DATETIME_TBL VALUES ('Feb 16 17:32:01 1997');
QUERY: INSERT INTO DATETIME_TBL VALUES ('Feb 16 17:32:01 0097 BC');
QUERY: INSERT INTO DATETIME_TBL VALUES ('Feb 16 17:32:01 0097');
QUERY: INSERT INTO DATETIME_TBL VALUES ('Feb 16 17:32:01 0597');
QUERY: INSERT INTO DATETIME_TBL VALUES ('Feb 16 17:32:01 1097');
QUERY: INSERT INTO DATETIME_TBL VALUES ('Feb 16 17:32:01 1697');
QUERY: INSERT INTO DATETIME_TBL VALUES ('Feb 16 17:32:01 1797');
QUERY: INSERT INTO DATETIME_TBL VALUES ('Feb 16 17:32:01 1897');
QUERY: INSERT INTO DATETIME_TBL VALUES ('Feb 16 17:32:01 1997');
QUERY: INSERT INTO DATETIME_TBL VALUES ('Feb 16 17:32:01 2097');
QUERY: INSERT INTO DATETIME_TBL VALUES ('Feb 28 17:32:01 1996');
QUERY: INSERT INTO DATETIME_TBL VALUES ('Feb 29 17:32:01 1996');
QUERY: INSERT INTO DATETIME_TBL VALUES ('Mar 01 17:32:01 1996');
QUERY: INSERT INTO DATETIME_TBL VALUES ('Dec 30 17:32:01 1996');
QUERY: INSERT INTO DATETIME_TBL VALUES ('Dec 31 17:32:01 1996');
QUERY: INSERT INTO DATETIME_TBL VALUES ('Jan 01 17:32:01 1997');
QUERY: INSERT INTO DATETIME_TBL VALUES ('Feb 28 17:32:01 1997');
QUERY: INSERT INTO DATETIME_TBL VALUES ('Feb 29 17:32:01 1997');
END;
DELETE FROM DATETIME_TBL;
-- Special values
INSERT INTO DATETIME_TBL VALUES ('invalid');
INSERT INTO DATETIME_TBL VALUES ('-infinity');
INSERT INTO DATETIME_TBL VALUES ('infinity');
INSERT INTO DATETIME_TBL VALUES ('epoch');
-- Postgres v6.0 standard output format
INSERT INTO DATETIME_TBL VALUES ('Mon Feb 10 17:32:01 1997 PST');
INSERT INTO DATETIME_TBL VALUES ('Invalid Abstime');
INSERT INTO DATETIME_TBL VALUES ('Undefined Abstime');
-- Variations on Postgres v6.1 standard output format
INSERT INTO DATETIME_TBL VALUES ('Mon Feb 10 17:32:01.000001 1997 PST');
INSERT INTO DATETIME_TBL VALUES ('Mon Feb 10 17:32:01.999999 1997 PST');
INSERT INTO DATETIME_TBL VALUES ('Mon Feb 10 17:32:01.4 1997 PST');
INSERT INTO DATETIME_TBL VALUES ('Mon Feb 10 17:32:01.5 1997 PST');
INSERT INTO DATETIME_TBL VALUES ('Mon Feb 10 17:32:01.6 1997 PST');
-- ISO 8601 format
INSERT INTO DATETIME_TBL VALUES ('1997-01-02');
INSERT INTO DATETIME_TBL VALUES ('1997-01-02 03:04:05');
INSERT INTO DATETIME_TBL VALUES ('1997-02-10 17:32:01-08');
INSERT INTO DATETIME_TBL VALUES ('1997-02-10 17:32:01-0800');
INSERT INTO DATETIME_TBL VALUES ('1997-02-10 17:32:01 -08:00');
INSERT INTO DATETIME_TBL VALUES ('19970210 173201 -0800');
INSERT INTO DATETIME_TBL VALUES ('1997-06-10 17:32:01 -07:00');
-- Variations for acceptable input formats
INSERT INTO DATETIME_TBL VALUES ('Feb 10 17:32:01 1997 -0800');
INSERT INTO DATETIME_TBL VALUES ('Feb 10 17:32:01 1997');
INSERT INTO DATETIME_TBL VALUES ('Feb 10 5:32PM 1997');
INSERT INTO DATETIME_TBL VALUES ('1997/02/10 17:32:01-0800');
INSERT INTO DATETIME_TBL VALUES ('1997-02-10 17:32:01 PST');
INSERT INTO DATETIME_TBL VALUES ('Feb-10-1997 17:32:01 PST');
INSERT INTO DATETIME_TBL VALUES ('02-10-1997 17:32:01 PST');
INSERT INTO DATETIME_TBL VALUES ('19970210 173201 PST');
INSERT INTO DATETIME_TBL VALUES ('97FEB10 5:32:01PM UTC');
INSERT INTO DATETIME_TBL VALUES ('97/02/10 17:32:01 UTC');
INSERT INTO DATETIME_TBL VALUES ('97.041 17:32:01 UTC');
-- Check date conversion and date arithmetic
INSERT INTO DATETIME_TBL VALUES ('1997-06-10 18:32:01 PDT');
INSERT INTO DATETIME_TBL VALUES ('Feb 10 17:32:01 1997');
INSERT INTO DATETIME_TBL VALUES ('Feb 11 17:32:01 1997');
INSERT INTO DATETIME_TBL VALUES ('Feb 12 17:32:01 1997');
INSERT INTO DATETIME_TBL VALUES ('Feb 13 17:32:01 1997');
INSERT INTO DATETIME_TBL VALUES ('Feb 14 17:32:01 1997');
INSERT INTO DATETIME_TBL VALUES ('Feb 15 17:32:01 1997');
INSERT INTO DATETIME_TBL VALUES ('Feb 16 17:32:01 1997');
INSERT INTO DATETIME_TBL VALUES ('Feb 16 17:32:01 0097 BC');
INSERT INTO DATETIME_TBL VALUES ('Feb 16 17:32:01 0097');
INSERT INTO DATETIME_TBL VALUES ('Feb 16 17:32:01 0597');
INSERT INTO DATETIME_TBL VALUES ('Feb 16 17:32:01 1097');
INSERT INTO DATETIME_TBL VALUES ('Feb 16 17:32:01 1697');
INSERT INTO DATETIME_TBL VALUES ('Feb 16 17:32:01 1797');
INSERT INTO DATETIME_TBL VALUES ('Feb 16 17:32:01 1897');
INSERT INTO DATETIME_TBL VALUES ('Feb 16 17:32:01 1997');
INSERT INTO DATETIME_TBL VALUES ('Feb 16 17:32:01 2097');
INSERT INTO DATETIME_TBL VALUES ('Feb 28 17:32:01 1996');
INSERT INTO DATETIME_TBL VALUES ('Feb 29 17:32:01 1996');
INSERT INTO DATETIME_TBL VALUES ('Mar 01 17:32:01 1996');
INSERT INTO DATETIME_TBL VALUES ('Dec 30 17:32:01 1996');
INSERT INTO DATETIME_TBL VALUES ('Dec 31 17:32:01 1996');
INSERT INTO DATETIME_TBL VALUES ('Jan 01 17:32:01 1997');
INSERT INTO DATETIME_TBL VALUES ('Feb 28 17:32:01 1997');
INSERT INTO DATETIME_TBL VALUES ('Feb 29 17:32:01 1997');
ERROR: Bad datetime external representation 'Feb 29 17:32:01 1997'
QUERY: INSERT INTO DATETIME_TBL VALUES ('Mar 01 17:32:01 1997');
QUERY: INSERT INTO DATETIME_TBL VALUES ('Dec 30 17:32:01 1997');
QUERY: INSERT INTO DATETIME_TBL VALUES ('Dec 31 17:32:01 1997');
QUERY: INSERT INTO DATETIME_TBL VALUES ('Dec 31 17:32:01 1999');
QUERY: INSERT INTO DATETIME_TBL VALUES ('Jan 01 17:32:01 2000');
QUERY: INSERT INTO DATETIME_TBL VALUES ('Dec 31 17:32:01 2000');
QUERY: INSERT INTO DATETIME_TBL VALUES ('Jan 01 17:32:01 2001');
QUERY: INSERT INTO DATETIME_TBL VALUES ('Feb 16 17:32:01 -0097');
INSERT INTO DATETIME_TBL VALUES ('Mar 01 17:32:01 1997');
INSERT INTO DATETIME_TBL VALUES ('Dec 30 17:32:01 1997');
INSERT INTO DATETIME_TBL VALUES ('Dec 31 17:32:01 1997');
INSERT INTO DATETIME_TBL VALUES ('Dec 31 17:32:01 1999');
INSERT INTO DATETIME_TBL VALUES ('Jan 01 17:32:01 2000');
INSERT INTO DATETIME_TBL VALUES ('Dec 31 17:32:01 2000');
INSERT INTO DATETIME_TBL VALUES ('Jan 01 17:32:01 2001');
-- Currently unsupported syntax and ranges
INSERT INTO DATETIME_TBL VALUES ('Feb 16 17:32:01 -0097');
ERROR: Bad datetime external representation 'Feb 16 17:32:01 -0097'
QUERY: INSERT INTO DATETIME_TBL VALUES ('Feb 16 17:32:01 5097 BC');
INSERT INTO DATETIME_TBL VALUES ('Feb 16 17:32:01 5097 BC');
ERROR: Datetime out of range 'Feb 16 17:32:01 5097 BC'
QUERY: SELECT '' AS sixtythree, d1 FROM DATETIME_TBL;
SELECT '' AS sixtythree, d1 FROM DATETIME_TBL;
sixtythree | d1
----------+-------------------------------
------------+---------------------------------
| invalid
| -infinity
| infinity
@ -223,10 +237,11 @@ sixtythree|d1
| Mon Jan 01 17:32:01 2001 PST
(61 rows)
QUERY: SELECT '' AS fortythree, d1 FROM DATETIME_TBL
WHERE d1 > '1997-01-02'::datetime and d1 != 'current'::datetime;
-- Demonstrate functions and operators
SELECT '' AS fortythree, d1 FROM DATETIME_TBL
WHERE d1 > datetime '1997-01-02' and d1 != datetime 'current';
fortythree | d1
----------+-------------------------------
------------+---------------------------------
| infinity
| Mon Feb 10 17:32:01 1997 PST
| Mon Feb 10 17:32:01.00 1997 PST
@ -271,10 +286,10 @@ fortythree|d1
| Mon Jan 01 17:32:01 2001 PST
(42 rows)
QUERY: SELECT '' AS fifteen, d1 FROM DATETIME_TBL
WHERE d1 < '1997-01-02'::datetime and d1 != 'current'::datetime;
SELECT '' AS fifteen, d1 FROM DATETIME_TBL
WHERE d1 < datetime '1997-01-02' and d1 != datetime 'current';
fifteen | d1
-------+----------------------------
---------+------------------------------
| -infinity
| epoch
| Tue Feb 16 17:32 0097 BC
@ -292,17 +307,17 @@ fifteen|d1
| Wed Jan 01 17:32:01 1997 PST
(15 rows)
QUERY: SELECT '' AS one, d1 FROM DATETIME_TBL
WHERE d1 = '1997-01-02'::datetime and d1 != 'current'::datetime;
SELECT '' AS one, d1 FROM DATETIME_TBL
WHERE d1 = datetime '1997-01-02' and d1 != datetime 'current';
one | d1
---+----------------------------
-----+------------------------------
| Thu Jan 02 00:00:00 1997 PST
(1 row)
QUERY: SELECT '' AS fiftyeight, d1 FROM DATETIME_TBL
WHERE d1 != '1997-01-02'::datetime and d1 != 'current'::datetime;
SELECT '' AS fiftyeight, d1 FROM DATETIME_TBL
WHERE d1 != datetime '1997-01-02' and d1 != datetime 'current';
fiftyeight | d1
----------+-------------------------------
------------+---------------------------------
| -infinity
| infinity
| epoch
@ -362,10 +377,10 @@ fiftyeight|d1
| Mon Jan 01 17:32:01 2001 PST
(57 rows)
QUERY: SELECT '' AS sixteen, d1 FROM DATETIME_TBL
WHERE d1 <= '1997-01-02'::datetime and d1 != 'current'::datetime;
SELECT '' AS sixteen, d1 FROM DATETIME_TBL
WHERE d1 <= datetime '1997-01-02' and d1 != datetime 'current';
sixteen | d1
-------+----------------------------
---------+------------------------------
| -infinity
| epoch
| Thu Jan 02 00:00:00 1997 PST
@ -384,10 +399,10 @@ sixteen|d1
| Wed Jan 01 17:32:01 1997 PST
(16 rows)
QUERY: SELECT '' AS fortyfour, d1 FROM DATETIME_TBL
WHERE d1 >= '1997-01-02'::datetime and d1 != 'current'::datetime;
SELECT '' AS fortyfour, d1 FROM DATETIME_TBL
WHERE d1 >= datetime '1997-01-02' and d1 != datetime 'current';
fortyfour | d1
---------+-------------------------------
-----------+---------------------------------
| infinity
| Mon Feb 10 17:32:01 1997 PST
| Mon Feb 10 17:32:01.00 1997 PST
@ -433,9 +448,9 @@ fortyfour|d1
| Mon Jan 01 17:32:01 2001 PST
(43 rows)
QUERY: SELECT '' AS sixtythree, d1 + '1 year'::timespan AS one_year FROM DATETIME_TBL;
SELECT '' AS sixtythree, d1 + timespan '1 year' AS one_year FROM DATETIME_TBL;
sixtythree | one_year
----------+-------------------------------
------------+---------------------------------
| invalid
| -infinity
| infinity
@ -499,9 +514,9 @@ sixtythree|one_year
| Tue Jan 01 17:32:01 2002 PST
(61 rows)
QUERY: SELECT '' AS sixtythree, d1 - '1 year'::timespan AS one_year FROM DATETIME_TBL;
SELECT '' AS sixtythree, d1 - timespan '1 year' AS one_year FROM DATETIME_TBL;
sixtythree | one_year
----------+-------------------------------
------------+---------------------------------
| invalid
| -infinity
| infinity
@ -565,10 +580,13 @@ sixtythree|one_year
| Sat Jan 01 17:32:01 2000 PST
(61 rows)
QUERY: SELECT '' AS fifty, d1 - '1997-01-02'::datetime AS diff
-- Casting within a BETWEEN qualifier should probably be allowed by the parser. - tgl 97/04/26
--SELECT '' AS fifty, d1 - datetime '1997-01-02' AS diff
-- FROM DATETIME_TBL WHERE d1 BETWEEN datetime '1902-01-01' AND datetime '2038-01-01';
SELECT '' AS fifty, d1 - datetime '1997-01-02' AS diff
FROM DATETIME_TBL WHERE d1 BETWEEN '1902-01-01' AND '2038-01-01';
fifty | diff
-----+--------------------------------------
-------+----------------------------------------
| @ 9863 days 8 hours ago
| @ 39 days 17 hours 32 mins 1 sec
| @ 39 days 17 hours 32 mins 1.00 secs
@ -619,12 +637,12 @@ fifty|diff
| @ 1460 days 17 hours 32 mins 1 sec
(48 rows)
QUERY: SELECT '' AS fortynine, date_part( 'year', d1) AS year, date_part( 'month', d1) AS month,
SELECT '' AS fortynine, date_part( 'year', d1) AS year, date_part( 'month', d1) AS month,
date_part( 'day', d1) AS day, date_part( 'hour', d1) AS hour,
date_part( 'minute', d1) AS minute, date_part( 'second', d1) AS second
FROM DATETIME_TBL WHERE d1 BETWEEN '1902-01-01' AND '2038-01-01';
fortynine | year | month | day | hour | minute | second
---------+----+-----+---+----+------+--------
-----------+------+-------+-----+------+--------+----------
| 1969 | 12 | 31 | 16 | 0 | 0
| 1997 | 2 | 10 | 17 | 32 | 1
| 1997 | 2 | 10 | 17 | 32 | 1.000001
@ -675,11 +693,11 @@ fortynine|year|month|day|hour|minute| second
| 2001 | 1 | 1 | 17 | 32 | 1
(48 rows)
QUERY: SELECT '' AS fortynine, date_part( 'quarter', d1) AS quarter, date_part( 'msec', d1) AS msec,
SELECT '' AS fortynine, date_part( 'quarter', d1) AS quarter, date_part( 'msec', d1) AS msec,
date_part( 'usec', d1) AS usec
FROM DATETIME_TBL WHERE d1 BETWEEN '1902-01-01' AND '2038-01-01';
fortynine | quarter | msec | usec
---------+-------+--------------------+-----------------
-----------+---------+----------------------+-------------------
| 4 | 0 | 0
| 1 | 0 | 0
| 1 | 0.000999999999917733 | 0.999999999917733

215
src/test/regress/expected/geometry.out
View File

@ -1,27 +1,33 @@
QUERY: SELECT '' AS four, center(f1) AS center
--
-- GEOMETRY
--
--
-- Points
--
SELECT '' AS four, center(f1) AS center
FROM BOX_TBL;
four | center
----+-------
------+---------
| (1,1)
| (2,2)
| (2.5,3)
| (3,3)
(4 rows)
QUERY: SELECT '' AS four, (@@ f1) AS center
SELECT '' AS four, (@@ f1) AS center
FROM BOX_TBL;
four | center
----+-------
------+---------
| (1,1)
| (2,2)
| (2.5,3)
| (3,3)
(4 rows)
QUERY: SELECT '' AS six, point(f1) AS center
SELECT '' AS six, point(f1) AS center
FROM CIRCLE_TBL;
six | center
---+---------
-----+-----------
| (0,0)
| (1,2)
| (1,3)
@ -30,10 +36,10 @@ six|center
| (100,0)
(6 rows)
QUERY: SELECT '' AS six, (@@ f1) AS center
SELECT '' AS six, (@@ f1) AS center
FROM CIRCLE_TBL;
six | center
---+---------
-----+-----------
| (0,0)
| (1,2)
| (1,3)
@ -42,57 +48,66 @@ six|center
| (100,0)
(6 rows)
QUERY: SELECT '' AS two, (@@ f1) AS center
SELECT '' AS two, (@@ f1) AS center
FROM POLYGON_TBL
WHERE (# f1) > 2;
two | center
---+-----------------------------------
-----+-------------------------------------
| (1.33333333333333,1.33333333333333)
| (2.33333333333333,1.33333333333333)
(2 rows)
QUERY: SELECT '' AS two, p1.f1
-- "is horizontal" function
SELECT '' AS two, p1.f1
FROM POINT_TBL p1
WHERE ishorizontal(p1.f1, '(0,0)'::point);
WHERE ishorizontal(p1.f1, point '(0,0)');
two | f1
---+-------
-----+---------
| (0,0)
| (-10,0)
(2 rows)
QUERY: SELECT '' AS two, p1.f1
-- "is horizontal" operator
SELECT '' AS two, p1.f1
FROM POINT_TBL p1
WHERE p1.f1 ?- '(0,0)'::point;
WHERE p1.f1 ?- point '(0,0)';
two | f1
---+-------
-----+---------
| (0,0)
| (-10,0)
(2 rows)
QUERY: SELECT '' AS one, p1.f1
-- "is vertical" function
SELECT '' AS one, p1.f1
FROM POINT_TBL p1
WHERE isvertical(p1.f1, '(5.1,34.5)'::point);
WHERE isvertical(p1.f1, point '(5.1,34.5)');
one | f1
---+----------
-----+------------
| (5.1,34.5)
(1 row)
QUERY: SELECT '' AS one, p1.f1
-- "is vertical" operator
SELECT '' AS one, p1.f1
FROM POINT_TBL p1
WHERE p1.f1 ?| '(5.1,34.5)'::point;
WHERE p1.f1 ?| point '(5.1,34.5)';
one | f1
---+----------
-----+------------
| (5.1,34.5)
(1 row)
QUERY: SELECT '' AS count, p.f1, l.s, l.s # p.f1 AS intersection
--
-- Line segments
--
-- intersection
SELECT '' AS count, p.f1, l.s, l.s # p.f1 AS intersection
FROM LSEG_TBL l, POINT_TBL p;
ERROR: Unable to identify an operator '#' for types 'lseg' and 'point'
You will have to retype this query using an explicit cast
QUERY: SELECT '' AS thirty, p.f1, l.s, p.f1 ## l.s AS closest
-- closest point
SELECT '' AS thirty, p.f1, l.s, p.f1 ## l.s AS closest
FROM LSEG_TBL l, POINT_TBL p;
thirty | f1 | s | closest
------+----------+-----------------------------+-------------------------------------
--------+------------+-------------------------------+---------------------------------------
| (0,0) | [(1,2),(3,4)] | (1,2)
| (-10,0) | [(1,2),(3,4)] | (1,2)
| (-3,4) | [(1,2),(3,4)] | (1,2)
@ -125,21 +140,28 @@ thirty|f1 |s |closest
| (10,10) | [(11,22),(33,44)] | (11,22)
(30 rows)
QUERY: SELECT '' as six, box(f1) AS box FROM CIRCLE_TBL;
--
-- Lines
--
--
-- Boxes
--
SELECT '' as six, box(f1) AS box FROM CIRCLE_TBL;
six | box
---+--------------------------------------------------------------------------
-----+----------------------------------------------------------------------------
| (2.12132034355964,2.12132034355964),(-2.12132034355964,-2.12132034355964)
|(71.7106781186548,72.7106781186548),(-69.7106781186548,-68.7106781186548)
|(4.53553390593274,6.53553390593274),(-2.53553390593274,-0.535533905932738)
|(3.12132034355964,4.12132034355964),(-1.12132034355964,-0.121320343559643)
| (71.7106781186547,72.7106781186547),(-69.7106781186547,-68.7106781186547)
| (4.53553390593274,6.53553390593274),(-2.53553390593274,-0.535533905932737)
| (3.12132034355964,4.12132034355964),(-1.12132034355964,-0.121320343559642)
| (107.071067811865,207.071067811865),(92.9289321881345,192.928932188135)
|(170.710678118655,70.7106781186548),(29.2893218813452,-70.7106781186548)
| (170.710678118655,70.7106781186547),(29.2893218813453,-70.7106781186547)
(6 rows)
QUERY: SELECT '' AS twentyfour, b.f1 + p.f1 AS translation
-- translation
SELECT '' AS twentyfour, b.f1 + p.f1 AS translation
FROM BOX_TBL b, POINT_TBL p;
twentyfour | translation
----------+-----------------------
------------+-------------------------
| (2,2),(0,0)
| (3,3),(1,1)
| (2.5,3.5),(2.5,2.5)
@ -166,10 +188,10 @@ twentyfour|translation
| (13,13),(13,13)
(24 rows)
QUERY: SELECT '' AS twentyfour, b.f1 - p.f1 AS translation
SELECT '' AS twentyfour, b.f1 - p.f1 AS translation
FROM BOX_TBL b, POINT_TBL p;
twentyfour | translation
----------+-------------------------
------------+---------------------------
| (2,2),(0,0)
| (3,3),(1,1)
| (2.5,3.5),(2.5,2.5)
@ -196,10 +218,11 @@ twentyfour|translation
| (-7,-7),(-7,-7)
(24 rows)
QUERY: SELECT '' AS twentyfour, b.f1 * p.f1 AS rotation
-- scaling and rotation
SELECT '' AS twentyfour, b.f1 * p.f1 AS rotation
FROM BOX_TBL b, POINT_TBL p;
twentyfour | rotation
----------+---------------------------
------------+-----------------------------
| (0,0),(0,0)
| (0,0),(0,0)
| (0,0),(0,0)
@ -226,11 +249,11 @@ twentyfour|rotation
| (0,60),(0,60)
(24 rows)
QUERY: SELECT '' AS twenty, b.f1 / p.f1 AS rotation
SELECT '' AS twenty, b.f1 / p.f1 AS rotation
FROM BOX_TBL b, POINT_TBL p
WHERE (p.f1 <-> '(0,0)'::point) >= 1;
WHERE (p.f1 <-> point '(0,0)') >= 1;
twenty | rotation
------+---------------------------------------------------------------------------------
--------+-----------------------------------------------------------------------------------
| (0,-0),(-0.2,-0.2)
| (-0.1,-0.1),(-0.3,-0.3)
| (-0.25,-0.25),(-0.25,-0.35)
@ -253,10 +276,13 @@ twenty|rotation
| (0.3,0),(0.3,0)
(20 rows)
QUERY: SET geqo TO 'off';
QUERY: SELECT '' AS eight, points(f1) AS npoints, f1 AS path FROM PATH_TBL;
--
-- Paths
--
SET geqo TO 'off';
SELECT '' AS eight, points(f1) AS npoints, f1 AS path FROM PATH_TBL;
eight | npoints | path
-----+-------+-------------------------
-------+---------+---------------------------
| 2 | [(1,2),(3,4)]
| 2 | ((1,2),(3,4))
| 4 | [(0,0),(3,0),(4,5),(1,6)]
@ -267,19 +293,20 @@ eight|npoints|path
| 2 | ((11,12),(13,14))
(8 rows)
QUERY: SELECT '' AS four, path(f1) FROM POLYGON_TBL;
SELECT '' AS four, path(f1) FROM POLYGON_TBL;
four | path
----+-------------------
------+---------------------
| ((2,0),(2,4),(0,0))
| ((3,1),(3,3),(1,0))
| ((0,0))
| ((0,1),(0,1))
(4 rows)
QUERY: SELECT '' AS eight, p1.f1 + '(10,10)'::point AS dist_add
-- translation
SELECT '' AS eight, p1.f1 + point '(10,10)' AS dist_add
FROM PATH_TBL p1;
eight | dist_add
-----+---------------------------------
-------+-----------------------------------
| [(11,12),(13,14)]
| ((11,12),(13,14))
| [(10,10),(13,10),(14,15),(11,16)]
@ -290,10 +317,11 @@ eight|dist_add
| ((21,22),(23,24))
(8 rows)
QUERY: SELECT '' AS eight, p1.f1 * '(2,-1)'::point AS dist_mul
-- scaling and rotation
SELECT '' AS eight, p1.f1 * point '(2,-1)' AS dist_mul
FROM PATH_TBL p1;
eight | dist_mul
-----+----------------------------
-------+------------------------------
| [(4,3),(10,5)]
| ((4,3),(10,5))
| [(0,0),(6,-3),(13,6),(8,11)]
@ -304,11 +332,15 @@ eight|dist_mul
| ((34,13),(40,15))
(8 rows)
QUERY: RESET geqo;
QUERY: SELECT '' AS twentyfour, p.f1, poly.f1, poly.f1 ~ p.f1 AS contains
RESET geqo;
--
-- Polygons
--
-- containment
SELECT '' AS twentyfour, p.f1, poly.f1, poly.f1 ~ p.f1 AS contains
FROM POLYGON_TBL poly, POINT_TBL p;
twentyfour | f1 | f1 | contains
----------+----------+-------------------+--------
------------+------------+---------------------+----------
| (0,0) | ((2,0),(2,4),(0,0)) | t
| (-10,0) | ((2,0),(2,4),(0,0)) | f
| (-3,4) | ((2,0),(2,4),(0,0)) | f
@ -335,10 +367,10 @@ twentyfour|f1 |f1 |contains
| (10,10) | ((0,1),(0,1)) | f
(24 rows)
QUERY: SELECT '' AS twentyfour, p.f1, poly.f1, p.f1 @ poly.f1 AS contained
SELECT '' AS twentyfour, p.f1, poly.f1, p.f1 @ poly.f1 AS contained
FROM POLYGON_TBL poly, POINT_TBL p;
twentyfour | f1 | f1 | contained
----------+----------+-------------------+---------
------------+------------+---------------------+-----------
| (0,0) | ((2,0),(2,4),(0,0)) | t
| (-10,0) | ((2,0),(2,4),(0,0)) | f
| (-3,4) | ((2,0),(2,4),(0,0)) | f
@ -365,75 +397,80 @@ twentyfour|f1 |f1 |contained
| (10,10) | ((0,1),(0,1)) | f
(24 rows)
QUERY: SELECT '' AS four, points(f1) AS npoints, f1 AS polygon
SELECT '' AS four, points(f1) AS npoints, f1 AS polygon
FROM POLYGON_TBL;
four | npoints | polygon
----+-------+-------------------
------+---------+---------------------
| 3 | ((2,0),(2,4),(0,0))
| 3 | ((3,1),(3,3),(1,0))
| 1 | ((0,0))
| 2 | ((0,1),(0,1))
(4 rows)
QUERY: SELECT '' AS four, polygon(f1)
SELECT '' AS four, polygon(f1)
FROM BOX_TBL;
four | polygon
----+-----------------------------------------
------+-------------------------------------------
| ((0,0),(0,2),(2,2),(2,0))
| ((1,1),(1,3),(3,3),(3,1))
| ((2.5,2.5),(2.5,3.5),(2.5,3.5),(2.5,2.5))
| ((3,3),(3,3),(3,3),(3,3))
(4 rows)
QUERY: SELECT '' AS four, polygon(f1)
SELECT '' AS four, polygon(f1)
FROM PATH_TBL WHERE isclosed(f1);
four | polygon
----+-----------------
------+-------------------
| ((1,2),(3,4))
| ((1,2),(3,4))
| ((1,2),(3,4))
| ((11,12),(13,14))
(4 rows)
QUERY: SELECT '' AS four, f1 AS open_path, polygon( pclose(f1)) AS polygon
SELECT '' AS four, f1 AS open_path, polygon( pclose(f1)) AS polygon
FROM PATH_TBL
WHERE isopen(f1);
four | open_path | polygon
----+-------------------------+-------------------------
------+---------------------------+---------------------------
| [(1,2),(3,4)] | ((1,2),(3,4))
| [(0,0),(3,0),(4,5),(1,6)] | ((0,0),(3,0),(4,5),(1,6))
| [(1,2),(3,4)] | ((1,2),(3,4))
| [(11,12),(13,14)] | ((11,12),(13,14))
(4 rows)
QUERY: SELECT '' AS six, polygon(f1)
-- convert circles to polygons using the default number of points
SELECT '' AS six, polygon(f1)
FROM CIRCLE_TBL;
six | polygon
---+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
|((-3,0),(-2.59807621135332,1.5),(-1.5,2.59807621135332),(-1.83690953073357e-16,3),(1.5,2.59807621135332),(2.59807621135332,1.5),(3,3.67381906146713e-16),(2.59807621135332,-1.5),(1.5,-2.59807621135332),(5.5107285922007e-16,-3),(-1.5,-2.59807621135332),(-2.59807621135332,-1.5))
|((-99,2),(-85.6025403784439,52),(-49,88.6025403784439),(0.999999999999994,102),(51,88.6025403784439),(87.6025403784439,52),(101,2.00000000000001),(87.6025403784439,-48),(51,-84.6025403784438),(1.00000000000002,-98),(-49,-84.6025403784439),(-85.6025403784438,-48))
|((-4,3),(-3.33012701892219,5.5),(-1.5,7.33012701892219),(1,8),(3.5,7.33012701892219),(5.33012701892219,5.5),(6,3),(5.33012701892219,0.500000000000001),(3.5,-1.33012701892219),(1,-2),(-1.5,-1.33012701892219),(-3.33012701892219,0.499999999999998))
|((-2,2),(-1.59807621135332,3.5),(-0.5,4.59807621135332),(1,5),(2.5,4.59807621135332),(3.59807621135332,3.5),(4,2),(3.59807621135332,0.500000000000001),(2.5,-0.598076211353315),(1,-1),(-0.5,-0.598076211353316),(-1.59807621135332,0.499999999999999))
|((90,200),(91.3397459621556,205),(95,208.660254037844),(100,210),(105,208.660254037844),(108.660254037844,205),(110,200),(108.660254037844,195),(105,191.339745962156),(100,190),(95,191.339745962156),(91.3397459621556,195))
|((0,0),(13.3974596215561,50),(50,86.6025403784439),(100,100),(150,86.6025403784439),(186.602540378444,50),(200,1.22460635382238e-14),(186.602540378444,-50),(150,-86.6025403784438),(100,-100),(50,-86.6025403784439),(13.3974596215562,-50))
-----+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
| ((-3,0),(-2.59807621135076,1.50000000000442),(-1.49999999999116,2.59807621135842),(1.53102359078377e-11,3),(1.50000000001768,2.59807621134311),(2.59807621136607,1.4999999999779),(3,-3.06204718156754e-11),(2.59807621133545,-1.50000000003094),(1.49999999996464,-2.59807621137373),(-4.59307077235131e-11,-3),(-1.5000000000442,-2.5980762113278),(-2.59807621138138,-1.49999999995138))
| ((-99,2),(-85.6025403783588,52.0000000001473),(-48.9999999997054,88.602540378614),(1.00000000051034,102),(51.0000000005893,88.6025403781036),(87.6025403788692,51.9999999992634),(101,1.99999999897932),(87.6025403778485,-48.0000000010313),(50.9999999988214,-84.6025403791243),(0.999999998468976,-98),(-49.0000000014732,-84.6025403775933),(-85.6025403793795,-47.9999999983795))
| ((-4,3),(-3.33012701891794,5.50000000000737),(-1.49999999998527,7.3301270189307),(1.00000000002552,8),(3.50000000002946,7.33012701890518),(5.33012701894346,5.49999999996317),(6,2.99999999994897),(5.33012701889242,0.499999999948437),(3.49999999994107,-1.33012701895622),(0.999999999923449,-2),(-1.50000000007366,-1.33012701887966),(-3.33012701896897,0.500000000081028))
| ((-2,2),(-1.59807621135076,3.50000000000442),(-0.499999999991161,4.59807621135842),(1.00000000001531,5),(2.50000000001768,4.59807621134311),(3.59807621136607,3.4999999999779),(4,1.99999999996938),(3.59807621133545,0.499999999969062),(2.49999999996464,-0.59807621137373),(0.999999999954069,-1),(-0.500000000044197,-0.598076211327799),(-1.59807621138138,0.500000000048617))
| ((90,200),(91.3397459621641,205.000000000015),(95.0000000000295,208.660254037861),(100.000000000051,210),(105.000000000059,208.66025403781),(108.660254037887,204.999999999926),(110,199.999999999898),(108.660254037785,194.999999999897),(104.999999999882,191.339745962088),(99.9999999998469,190),(94.9999999998527,191.339745962241),(91.3397459620621,195.000000000162))
| ((0,0),(13.3974596216412,50.0000000001473),(50.0000000002946,86.602540378614),(100.00000000051,100),(150.000000000589,86.6025403781036),(186.602540378869,49.9999999992634),(200,-1.02068239385585e-09),(186.602540377848,-50.0000000010313),(149.999999998821,-86.6025403791243),(99.999999998469,-100),(49.9999999985268,-86.6025403775933),(13.3974596206205,-49.9999999983795))
(6 rows)
QUERY: SELECT '' AS six, polygon(8, f1)
-- convert the circle to an 8-point polygon
SELECT '' AS six, polygon(8, f1)
FROM CIRCLE_TBL;
six | polygon
---+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
|((-3,0),(-2.12132034355964,2.12132034355964),(-1.83690953073357e-16,3),(2.12132034355964,2.12132034355964),(3,3.67381906146713e-16),(2.12132034355964,-2.12132034355964),(5.5107285922007e-16,-3),(-2.12132034355964,-2.12132034355964))
|((-99,2),(-69.7106781186548,72.7106781186548),(0.999999999999994,102),(71.7106781186547,72.7106781186548),(101,2.00000000000001),(71.7106781186548,-68.7106781186547),(1.00000000000002,-98),(-69.7106781186547,-68.7106781186548))
|((-4,3),(-2.53553390593274,6.53553390593274),(1,8),(4.53553390593274,6.53553390593274),(6,3),(4.53553390593274,-0.535533905932737),(1,-2),(-2.53553390593274,-0.535533905932738))
|((-2,2),(-1.12132034355964,4.12132034355964),(1,5),(3.12132034355964,4.12132034355964),(4,2),(3.12132034355964,-0.121320343559642),(1,-1),(-1.12132034355964,-0.121320343559643))
|((90,200),(92.9289321881345,207.071067811865),(100,210),(107.071067811865,207.071067811865),(110,200),(107.071067811865,192.928932188135),(100,190),(92.9289321881345,192.928932188135))
|((0,0),(29.2893218813452,70.7106781186548),(100,100),(170.710678118655,70.7106781186548),(200,1.22460635382238e-14),(170.710678118655,-70.7106781186547),(100,-100),(29.2893218813453,-70.7106781186548))
-----+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
| ((-3,0),(-2.12132034355423,2.12132034356506),(1.53102359078377e-11,3),(2.12132034357588,2.1213203435434),(3,-3.06204718156754e-11),(2.12132034353258,-2.12132034358671),(-4.59307077235131e-11,-3),(-2.12132034359753,-2.12132034352175))
| ((-99,2),(-69.7106781184743,72.7106781188352),(1.00000000051034,102),(71.710678119196,72.7106781181134),(101,1.99999999897932),(71.7106781177526,-68.7106781195569),(0.999999998468976,-98),(-69.7106781199178,-68.7106781173917))
| ((-4,3),(-2.53553390592372,6.53553390594176),(1.00000000002552,8),(4.5355339059598,6.53553390590567),(6,2.99999999994897),(4.53553390588763,-0.535533905977846),(0.999999999923449,-2),(-2.53553390599589,-0.535533905869586))
| ((-2,2),(-1.12132034355423,4.12132034356506),(1.00000000001531,5),(3.12132034357588,4.1213203435434),(4,1.99999999996938),(3.12132034353258,-0.121320343586707),(0.999999999954069,-1),(-1.12132034359753,-0.121320343521752))
| ((90,200),(92.9289321881526,207.071067811884),(100.000000000051,210),(107.07106781192,207.071067811811),(110,199.999999999898),(107.071067811775,192.928932188044),(99.9999999998469,190),(92.9289321880082,192.928932188261))
| ((0,0),(29.2893218815257,70.7106781188352),(100.00000000051,100),(170.710678119196,70.7106781181134),(200,-1.02068239385585e-09),(170.710678117753,-70.7106781195569),(99.999999998469,-100),(29.2893218800822,-70.7106781173917))
(6 rows)
QUERY: SELECT '' AS six, circle(f1, 50.0)
--
-- Circles
--
SELECT '' AS six, circle(f1, 50.0)
FROM POINT_TBL;
six | circle
---+---------------
-----+-----------------
| <(0,0),50>
| <(-10,0),50>
| <(-3,4),50>
@ -442,35 +479,35 @@ six|circle
| <(10,10),50>
(6 rows)
QUERY: SELECT '' AS four, circle(f1)
SELECT '' AS four, circle(f1)
FROM BOX_TBL;
four | circle
----+-----------------------
------+-------------------------
| <(1,1),1.4142135623731>
| <(2,2),1.4142135623731>
| <(2.5,3),0.5>
| <(3,3),0>
(4 rows)
QUERY: SELECT '' AS two, circle(f1)
SELECT '' AS two, circle(f1)
FROM POLYGON_TBL
WHERE (# f1) >= 3;
two | circle
---+------------------------------------------------------
-----+--------------------------------------------------------
| <(1.33333333333333,1.33333333333333),2.04168905063636>
| <(2.33333333333333,1.33333333333333),1.47534300379185>
(2 rows)
QUERY: SELECT '' AS twentyfour, c1.f1 AS circle, p1.f1 AS point, (p1.f1 <-> c1.f1) AS distance
SELECT '' AS twentyfour, c1.f1 AS circle, p1.f1 AS point, (p1.f1 <-> c1.f1) AS distance
FROM CIRCLE_TBL c1, POINT_TBL p1
WHERE (p1.f1 <-> c1.f1) > 0
ORDER BY distance, circle, point using <<;
twentyfour | circle | point | distance
----------+--------------+----------+-----------------
|<(100,0),100> |(5.1,34.5)|0.976531926977964
------------+----------------+------------+------------------
| <(100,0),100> | (5.1,34.5) | 0.97653192697797
| <(1,2),3> | (-3,4) | 1.47213595499958
| <(0,0),3> | (-3,4) | 2
|<(100,0),100> |(-3,4) | 3.07764064044151
| <(100,0),100> | (-3,4) | 3.07764064044152
| <(100,0),100> | (-5,-12) | 5.68348972285122
| <(1,3),5> | (-10,0) | 6.40175425099138
| <(1,3),5> | (10,10) | 6.40175425099138
@ -482,7 +519,7 @@ twentyfour|circle |point | distance
| <(0,0),3> | (10,10) | 11.142135623731
| <(1,3),5> | (-5,-12) | 11.1554944214035
| <(1,2),3> | (-5,-12) | 12.2315462117278
|<(1,3),5> |(5.1,34.5)| 26.7657047773224
| <(1,3),5> | (5.1,34.5) | 26.7657047773223
| <(1,2),3> | (5.1,34.5) | 29.757594539282
| <(0,0),3> | (5.1,34.5) | 31.8749193547455
| <(100,200),10> | (5.1,34.5) | 180.778038568384

275
src/test/regress/expected/horology.out
View File

@ -1,13 +1,44 @@
QUERY: CREATE TABLE TEMP_DATETIME (f1 datetime);
QUERY: INSERT INTO TEMP_DATETIME (f1)
--
-- HOROLOGY
--
--
-- datetime, timespan arithmetic
--
SELECT datetime '1996-03-01' - timespan '1 second' AS "Feb 29";
Feb 29
------------------------------
Thu Feb 29 23:59:59 1996 PST
(1 row)
SELECT datetime '1999-03-01' - timespan '1 second' AS "Feb 28";
Feb 28
------------------------------
Sun Feb 28 23:59:59 1999 PST
(1 row)
SELECT datetime '2000-03-01' - timespan '1 second' AS "Feb 29";
Feb 29
------------------------------
Tue Feb 29 23:59:59 2000 PST
(1 row)
SELECT datetime '1999-12-01' + timespan '1 month - 1 second' AS "Dec 31";
Dec 31
------------------------------
Fri Dec 31 23:59:59 1999 PST
(1 row)
CREATE TABLE TEMP_DATETIME (f1 datetime);
-- get some candidate input values
INSERT INTO TEMP_DATETIME (f1)
SELECT d1 FROM DATETIME_TBL
WHERE d1 BETWEEN '13-jun-1957' AND '1-jan-1997'
OR d1 BETWEEN '1-jan-1999' AND '1-jan-2010';
QUERY: SELECT '' AS ten, f1 AS datetime
SELECT '' AS ten, f1 AS datetime
FROM TEMP_DATETIME
ORDER BY datetime;
ten | datetime
---+----------------------------
-----+------------------------------
| epoch
| Wed Feb 28 17:32:01 1996 PST
| Thu Feb 29 17:32:01 1996 PST
@ -20,11 +51,11 @@ ten|datetime
| Mon Jan 01 17:32:01 2001 PST
(10 rows)
QUERY: SELECT '' AS hundred, d.f1 AS datetime, t.f1 AS timespan, d.f1 + t.f1 AS plus
SELECT '' AS hundred, d.f1 AS datetime, t.f1 AS timespan, d.f1 + t.f1 AS plus
FROM TEMP_DATETIME d, TIMESPAN_TBL t
ORDER BY plus, datetime, timespan;
hundred | datetime | timespan | plus
-------+----------------------------+-----------------------------+----------------------------
---------+------------------------------+-------------------------------+------------------------------
| epoch | @ 14 secs ago | Wed Dec 31 15:59:46 1969 PST
| epoch | @ 1 min | Wed Dec 31 16:01:00 1969 PST
| epoch | @ 5 hours | Wed Dec 31 21:00:00 1969 PST
@ -55,7 +86,7 @@ hundred|datetime |timespan |plus
| Wed Feb 28 17:32:01 1996 PST | @ 5 mons | Sun Jul 28 18:32:01 1996 PDT
| Wed Feb 28 17:32:01 1996 PST | @ 5 mons 12 hours | Mon Jul 29 06:32:01 1996 PDT
| Thu Feb 29 17:32:01 1996 PST | @ 5 mons | Mon Jul 29 18:32:01 1996 PDT
|Thu Feb 29 17:32:01 1996 PST|@ 5 mons 12 hours |Thu Aug 01 06:32:01 1996 PDT
| Thu Feb 29 17:32:01 1996 PST | @ 5 mons 12 hours | Tue Jul 30 06:32:01 1996 PDT
| Fri Mar 01 17:32:01 1996 PST | @ 5 mons | Thu Aug 01 18:32:01 1996 PDT
| Fri Mar 01 17:32:01 1996 PST | @ 5 mons 12 hours | Fri Aug 02 06:32:01 1996 PDT
| Mon Dec 30 17:32:01 1996 PST | @ 14 secs ago | Mon Dec 30 17:31:47 1996 PST
@ -127,12 +158,12 @@ hundred|datetime |timespan |plus
| Mon Jan 01 17:32:01 2001 PST | @ 34 years | Mon Jan 01 17:32:01 2035 PST
(100 rows)
QUERY: SELECT '' AS hundred, d.f1 AS datetime, t.f1 AS timespan, d.f1 - t.f1 AS minus
SELECT '' AS hundred, d.f1 AS datetime, t.f1 AS timespan, d.f1 - t.f1 AS minus
FROM TEMP_DATETIME d, TIMESPAN_TBL t
WHERE isfinite(d.f1)
ORDER BY minus, datetime, timespan;
hundred | datetime | timespan | minus
-------+----------------------------+-----------------------------+----------------------------
---------+------------------------------+-------------------------------+------------------------------
| epoch | @ 34 years | Tue Dec 31 16:00:00 1935 PST
| Wed Feb 28 17:32:01 1996 PST | @ 34 years | Wed Feb 28 17:32:01 1962 PST
| Thu Feb 29 17:32:01 1996 PST | @ 34 years | Wed Feb 28 17:32:01 1962 PST
@ -235,12 +266,12 @@ hundred|datetime |timespan |minus
| Mon Jan 01 17:32:01 2001 PST | @ 14 secs ago | Mon Jan 01 17:32:15 2001 PST
(100 rows)
QUERY: SELECT '' AS ten, d.f1 AS datetime, '1980-01-06 00:00 GMT'::datetime AS gpstime_zero,
d.f1 - '1980-01-06 00:00 GMT'::datetime AS difference
SELECT '' AS ten, d.f1 AS datetime, datetime '1980-01-06 00:00 GMT' AS gpstime_zero,
d.f1 - datetime '1980-01-06 00:00 GMT' AS difference
FROM TEMP_DATETIME d
ORDER BY difference;
ten | datetime | gpstime_zero | difference
---+----------------------------+----------------------------+--------------------------------
-----+------------------------------+------------------------------+----------------------------------
| epoch | Sat Jan 05 16:00:00 1980 PST | @ 3657 days ago
| Wed Feb 28 17:32:01 1996 PST | Sat Jan 05 16:00:00 1980 PST | @ 5898 days 1 hour 32 mins 1 sec
| Thu Feb 29 17:32:01 1996 PST | Sat Jan 05 16:00:00 1980 PST | @ 5899 days 1 hour 32 mins 1 sec
@ -253,11 +284,11 @@ ten|datetime |gpstime_zero |difference
| Mon Jan 01 17:32:01 2001 PST | Sat Jan 05 16:00:00 1980 PST | @ 7667 days 1 hour 32 mins 1 sec
(10 rows)
QUERY: SELECT '' AS hundred, d1.f1 AS datetime1, d2.f1 AS datetime2, d1.f1 - d2.f1 AS difference
SELECT '' AS hundred, d1.f1 AS datetime1, d2.f1 AS datetime2, d1.f1 - d2.f1 AS difference
FROM TEMP_DATETIME d1, TEMP_DATETIME d2
ORDER BY datetime1, datetime2, difference;
hundred | datetime1 | datetime2 | difference
-------+----------------------------+----------------------------+-------------------------------------
---------+------------------------------+------------------------------+---------------------------------------
| epoch | epoch | @ 0
| epoch | Wed Feb 28 17:32:01 1996 PST | @ 9555 days 1 hour 32 mins 1 sec ago
| epoch | Thu Feb 29 17:32:01 1996 PST | @ 9556 days 1 hour 32 mins 1 sec ago
@ -360,7 +391,7 @@ hundred|datetime1 |datetime2 |difference
| Mon Jan 01 17:32:01 2001 PST | Mon Jan 01 17:32:01 2001 PST | @ 0
(100 rows)
QUERY: SELECT '' as fifty, d1 as datetime,
SELECT '' as fifty, d1 as datetime,
date_part('year', d1) AS year, date_part('month', d1) AS month,
date_part('day',d1) AS day, date_part('hour', d1) AS hour,
date_part('minute', d1) AS minute, date_part('second', d1) AS second
@ -368,7 +399,7 @@ QUERY: SELECT '' as fifty, d1 as datetime,
WHERE isfinite(d1) and d1 >= '1-jan-1900 GMT'
ORDER BY datetime;
fifty | datetime | year | month | day | hour | minute | second
-----+-------------------------------+----+-----+---+----+------+--------
-------+---------------------------------+------+-------+-----+------+--------+----------
| epoch | 1969 | 12 | 31 | 16 | 0 | 0
| Wed Feb 28 17:32:01 1996 PST | 1996 | 2 | 28 | 17 | 32 | 1
| Thu Feb 29 17:32:01 1996 PST | 1996 | 2 | 29 | 17 | 32 | 1
@ -420,27 +451,33 @@ fifty|datetime |year|month|day|hour|minute| second
| Sat Feb 16 17:32:01 2097 | 2097 | 2 | 16 | 17 | 32 | 1
(49 rows)
QUERY: SELECT '' AS four, f1 AS abstime,
--
-- abstime, reltime arithmetic
--
SELECT '' AS four, f1 AS abstime,
date_part('year', f1) AS year, date_part('month', f1) AS month,
date_part('day',f1) AS day, date_part('hour', f1) AS hour,
date_part('minute', f1) AS minute, date_part('second', f1) AS second
FROM ABSTIME_TBL
WHERE isfinite(f1) and f1 <> 'current'::abstime
WHERE isfinite(f1) and f1 <> abstime 'current'
ORDER BY abstime;
four | abstime | year | month | day | hour | minute | second
----+----------------------------+----+-----+---+----+------+------
------+------------------------------+------+-------+-----+------+--------+--------
| Sat May 10 23:59:12 1947 PST | 1947 | 5 | 10 | 23 | 59 | 12
| epoch | 1969 | 12 | 31 | 16 | 0 | 0
| Sun Jan 14 03:14:21 1973 PST | 1973 | 1 | 14 | 3 | 14 | 21
| Mon May 01 00:30:30 1995 PDT | 1995 | 5 | 1 | 0 | 30 | 30
(4 rows)
QUERY: SELECT '' AS ten, f1 AS datetime, date( f1) AS date
--
-- conversions
--
SELECT '' AS ten, f1 AS datetime, date( f1) AS date
FROM TEMP_DATETIME
WHERE f1 <> 'current'::datetime
WHERE f1 <> datetime 'current'
ORDER BY date;
ten | datetime | date
---+----------------------------+----------
-----+------------------------------+------------
| epoch | 01-01-1970
| Wed Feb 28 17:32:01 1996 PST | 02-28-1996
| Thu Feb 29 17:32:01 1996 PST | 02-29-1996
@ -453,11 +490,11 @@ ten|datetime | date
| Mon Jan 01 17:32:01 2001 PST | 01-01-2001
(10 rows)
QUERY: SELECT '' AS ten, f1 AS datetime, abstime( f1) AS abstime
SELECT '' AS ten, f1 AS datetime, abstime( f1) AS abstime
FROM TEMP_DATETIME
ORDER BY abstime;
ten | datetime | abstime
---+----------------------------+----------------------------
-----+------------------------------+------------------------------
| epoch | epoch
| Wed Feb 28 17:32:01 1996 PST | Wed Feb 28 17:32:01 1996 PST
| Thu Feb 29 17:32:01 1996 PST | Thu Feb 29 17:32:01 1996 PST
@ -470,22 +507,22 @@ ten|datetime |abstime
| Mon Jan 01 17:32:01 2001 PST | Mon Jan 01 17:32:01 2001 PST
(10 rows)
QUERY: SELECT '' AS five, f1 AS abstime, date( f1) AS date
SELECT '' AS five, f1 AS abstime, date( f1) AS date
FROM ABSTIME_TBL
WHERE isfinite(f1) AND f1 <> 'current'::abstime
WHERE isfinite(f1) AND f1 <> abstime 'current'
ORDER BY date;
five | abstime | date
----+----------------------------+----------
------+------------------------------+------------
| Sat May 10 23:59:12 1947 PST | 05-10-1947
| epoch | 01-01-1970
| Sun Jan 14 03:14:21 1973 PST | 01-14-1973
| Mon May 01 00:30:30 1995 PDT | 05-01-1995
(4 rows)
QUERY: SELECT '' AS five, d1 AS datetime, abstime(d1) AS abstime
SELECT '' AS five, d1 AS datetime, abstime(d1) AS abstime
FROM DATETIME_TBL WHERE NOT isfinite(d1);
five | datetime | abstime
----+---------+---------
------+-----------+-----------
| invalid | invalid
| -infinity | -infinity
| infinity | infinity
@ -493,19 +530,19 @@ five|datetime |abstime
| invalid | invalid
(5 rows)
QUERY: SELECT '' AS three, f1 as abstime, datetime(f1) AS datetime
SELECT '' AS three, f1 as abstime, datetime(f1) AS datetime
FROM ABSTIME_TBL WHERE NOT isfinite(f1);
three | abstime | datetime
-----+---------+---------
-------+-----------+-----------
| infinity | infinity
| -infinity | -infinity
| invalid | invalid
(3 rows)
QUERY: SELECT '' AS ten, f1 AS timespan, reltime( f1) AS reltime
SELECT '' AS ten, f1 AS timespan, reltime( f1) AS reltime
FROM TIMESPAN_TBL;
ten | timespan | reltime
---+-----------------------------+-----------------------------
-----+-------------------------------+-------------------------------
| @ 1 min | @ 1 min
| @ 5 hours | @ 5 hours
| @ 10 days | @ 10 days
@ -518,10 +555,10 @@ ten|timespan |reltime
| @ 5 mons 12 hours | @ 5 mons 12 hours
(10 rows)
QUERY: SELECT '' AS six, f1 as reltime, timespan( f1) AS timespan
SELECT '' AS six, f1 as reltime, timespan( f1) AS timespan
FROM RELTIME_TBL;
six | reltime | timespan
---+-------------+-------------
-----+---------------+---------------
| @ 1 min | @ 1 min
| @ 5 hours | @ 5 hours
| @ 10 days | @ 10 days
@ -530,13 +567,16 @@ six|reltime |timespan
| @ 14 secs ago | @ 14 secs ago
(6 rows)
QUERY: DROP TABLE TEMP_DATETIME;
QUERY: SET DateStyle TO 'US,Postgres';
QUERY: SHOW DateStyle;
DROP TABLE TEMP_DATETIME;
--
-- formats
--
SET DateStyle TO 'US,Postgres';
NOTICE: DateStyle is Postgres with US (NonEuropean) conventions
QUERY: SELECT '' AS sixty_two, d1 AS us_postgres FROM DATETIME_TBL;
SHOW DateStyle;
SELECT '' AS sixty_two, d1 AS us_postgres FROM DATETIME_TBL;
sixty_two | us_postgres
---------+-------------------------------
-----------+---------------------------------
| invalid
| -infinity
| infinity
@ -600,9 +640,9 @@ sixty_two|us_postgres
| Mon Jan 01 17:32:01 2001 PST
(61 rows)
QUERY: SELECT '' AS eight, f1 AS us_postgres FROM ABSTIME_TBL;
SELECT '' AS eight, f1 AS us_postgres FROM ABSTIME_TBL;
eight | us_postgres
-----+----------------------------
-------+------------------------------
| Sun Jan 14 03:14:21 1973 PST
| Mon May 01 00:30:30 1995 PDT
| epoch
@ -613,10 +653,10 @@ eight|us_postgres
| invalid
(8 rows)
QUERY: SET DateStyle TO 'US,ISO';
QUERY: SELECT '' AS sixty_two, d1 AS us_iso FROM DATETIME_TBL;
SET DateStyle TO 'US,ISO';
SELECT '' AS sixty_two, d1 AS us_iso FROM DATETIME_TBL;
sixty_two | us_iso
---------+-------------------------
-----------+---------------------------
| invalid
| -infinity
| infinity
@ -680,9 +720,9 @@ sixty_two|us_iso
| 2001-01-01 17:32:01-08
(61 rows)
QUERY: SELECT '' AS eight, f1 AS us_iso FROM ABSTIME_TBL;
SELECT '' AS eight, f1 AS us_iso FROM ABSTIME_TBL;
eight | us_iso
-----+----------------------
-------+------------------------
| 1973-01-14 03:14:21-08
| 1995-05-01 00:30:30-07
| epoch
@ -693,12 +733,12 @@ eight|us_iso
| invalid
(8 rows)
QUERY: SET DateStyle TO 'US,SQL';
QUERY: SHOW DateStyle;
SET DateStyle TO 'US,SQL';
NOTICE: DateStyle is SQL with US (NonEuropean) conventions
QUERY: SELECT '' AS sixty_two, d1 AS us_sql FROM DATETIME_TBL;
SHOW DateStyle;
SELECT '' AS sixty_two, d1 AS us_sql FROM DATETIME_TBL;
sixty_two | us_sql
---------+--------------------------
-----------+----------------------------
| invalid
| -infinity
| infinity
@ -762,9 +802,9 @@ sixty_two|us_sql
| 01/01/2001 17:32:01.00 PST
(61 rows)
QUERY: SELECT '' AS eight, f1 AS us_sql FROM ABSTIME_TBL;
SELECT '' AS eight, f1 AS us_sql FROM ABSTIME_TBL;
eight | us_sql
-----+--------------------------
-------+----------------------------
| 01/14/1973 03:14:21.00 PST
| 05/01/1995 00:30:30.00 PDT
| epoch
@ -775,19 +815,19 @@ eight|us_sql
| invalid
(8 rows)
QUERY: SET DateStyle TO 'European,Postgres';
QUERY: SHOW DateStyle;
SET DateStyle TO 'European,Postgres';
NOTICE: DateStyle is Postgres with European conventions
QUERY: INSERT INTO DATETIME_TBL VALUES('13/06/1957');
QUERY: SELECT count(*) as one FROM DATETIME_TBL WHERE d1 = 'Jun 13 1957';
SHOW DateStyle;
INSERT INTO DATETIME_TBL VALUES('13/06/1957');
SELECT count(*) as one FROM DATETIME_TBL WHERE d1 = 'Jun 13 1957';
one
---
-----
1
(1 row)
QUERY: SELECT '' AS sixty_three, d1 AS european_postgres FROM DATETIME_TBL;
SELECT '' AS sixty_three, d1 AS european_postgres FROM DATETIME_TBL;
sixty_three | european_postgres
-----------+-------------------------------
-------------+---------------------------------
| invalid
| -infinity
| infinity
@ -852,9 +892,9 @@ sixty_three|european_postgres
| Thu 13 Jun 00:00:00 1957 PDT
(62 rows)
QUERY: SELECT '' AS eight, f1 AS european_postgres FROM ABSTIME_TBL;
SELECT '' AS eight, f1 AS european_postgres FROM ABSTIME_TBL;
eight | european_postgres
-----+----------------------------
-------+------------------------------
| Sun 14 Jan 03:14:21 1973 PST
| Mon 01 May 00:30:30 1995 PDT
| epoch
@ -865,12 +905,12 @@ eight|european_postgres
| invalid
(8 rows)
QUERY: SET DateStyle TO 'European,ISO';
QUERY: SHOW DateStyle;
SET DateStyle TO 'European,ISO';
NOTICE: DateStyle is ISO with European conventions
QUERY: SELECT '' AS sixty_three, d1 AS european_iso FROM DATETIME_TBL;
SHOW DateStyle;
SELECT '' AS sixty_three, d1 AS european_iso FROM DATETIME_TBL;
sixty_three | european_iso
-----------+-------------------------
-------------+---------------------------
| invalid
| -infinity
| infinity
@ -935,9 +975,9 @@ sixty_three|european_iso
| 1957-06-13 00:00:00-07
(62 rows)
QUERY: SELECT '' AS eight, f1 AS european_iso FROM ABSTIME_TBL;
SELECT '' AS eight, f1 AS european_iso FROM ABSTIME_TBL;
eight | european_iso
-----+----------------------
-------+------------------------
| 1973-01-14 03:14:21-08
| 1995-05-01 00:30:30-07
| epoch
@ -948,12 +988,12 @@ eight|european_iso
| invalid
(8 rows)
QUERY: SET DateStyle TO 'European,SQL';
QUERY: SHOW DateStyle;
SET DateStyle TO 'European,SQL';
NOTICE: DateStyle is SQL with European conventions
QUERY: SELECT '' AS sixty_three, d1 AS european_sql FROM DATETIME_TBL;
SHOW DateStyle;
SELECT '' AS sixty_three, d1 AS european_sql FROM DATETIME_TBL;
sixty_three | european_sql
-----------+--------------------------
-------------+----------------------------
| invalid
| -infinity
| infinity
@ -1018,9 +1058,9 @@ sixty_three|european_sql
| 13/06/1957 00:00:00.00 PDT
(62 rows)
QUERY: SELECT '' AS eight, f1 AS european_sql FROM ABSTIME_TBL;
SELECT '' AS eight, f1 AS european_sql FROM ABSTIME_TBL;
eight | european_sql
-----+--------------------------
-------+----------------------------
| 14/01/1973 03:14:21.00 PST
| 01/05/1995 00:30:30.00 PDT
| epoch
@ -1031,15 +1071,18 @@ eight|european_sql
| invalid
(8 rows)
QUERY: RESET DateStyle;
QUERY: SHOW DateStyle;
RESET DateStyle;
NOTICE: DateStyle is Postgres with US (NonEuropean) conventions
QUERY: SET DateStyle TO 'US,Postgres';
QUERY: SHOW DateStyle;
SHOW DateStyle;
--
-- formats
--
SET DateStyle TO 'US,Postgres';
NOTICE: DateStyle is Postgres with US (NonEuropean) conventions
QUERY: SELECT '' AS sixty_two, d1 AS us_postgres FROM DATETIME_TBL;
SHOW DateStyle;
SELECT '' AS sixty_two, d1 AS us_postgres FROM DATETIME_TBL;
sixty_two | us_postgres
---------+-------------------------------
-----------+---------------------------------
| invalid
| -infinity
| infinity
@ -1104,9 +1147,9 @@ sixty_two|us_postgres
| Thu Jun 13 00:00:00 1957 PDT
(62 rows)
QUERY: SELECT '' AS eight, f1 AS us_postgres FROM ABSTIME_TBL;
SELECT '' AS eight, f1 AS us_postgres FROM ABSTIME_TBL;
eight | us_postgres
-----+----------------------------
-------+------------------------------
| Sun Jan 14 03:14:21 1973 PST
| Mon May 01 00:30:30 1995 PDT
| epoch
@ -1117,10 +1160,10 @@ eight|us_postgres
| invalid
(8 rows)
QUERY: SET DateStyle TO 'US,ISO';
QUERY: SELECT '' AS sixty_two, d1 AS us_iso FROM DATETIME_TBL;
SET DateStyle TO 'US,ISO';
SELECT '' AS sixty_two, d1 AS us_iso FROM DATETIME_TBL;
sixty_two | us_iso
---------+-------------------------
-----------+---------------------------
| invalid
| -infinity
| infinity
@ -1185,9 +1228,9 @@ sixty_two|us_iso
| 1957-06-13 00:00:00-07
(62 rows)
QUERY: SELECT '' AS eight, f1 AS us_iso FROM ABSTIME_TBL;
SELECT '' AS eight, f1 AS us_iso FROM ABSTIME_TBL;
eight | us_iso
-----+----------------------
-------+------------------------
| 1973-01-14 03:14:21-08
| 1995-05-01 00:30:30-07
| epoch
@ -1198,12 +1241,12 @@ eight|us_iso
| invalid
(8 rows)
QUERY: SET DateStyle TO 'US,SQL';
QUERY: SHOW DateStyle;
SET DateStyle TO 'US,SQL';
NOTICE: DateStyle is SQL with US (NonEuropean) conventions
QUERY: SELECT '' AS sixty_two, d1 AS us_sql FROM DATETIME_TBL;
SHOW DateStyle;
SELECT '' AS sixty_two, d1 AS us_sql FROM DATETIME_TBL;
sixty_two | us_sql
---------+--------------------------
-----------+----------------------------
| invalid
| -infinity
| infinity
@ -1268,9 +1311,9 @@ sixty_two|us_sql
| 06/13/1957 00:00:00.00 PDT
(62 rows)
QUERY: SELECT '' AS eight, f1 AS us_sql FROM ABSTIME_TBL;
SELECT '' AS eight, f1 AS us_sql FROM ABSTIME_TBL;
eight | us_sql
-----+--------------------------
-------+----------------------------
| 01/14/1973 03:14:21.00 PST
| 05/01/1995 00:30:30.00 PDT
| epoch
@ -1281,19 +1324,19 @@ eight|us_sql
| invalid
(8 rows)
QUERY: SET DateStyle TO 'European,Postgres';
QUERY: SHOW DateStyle;
SET DateStyle TO 'European,Postgres';
NOTICE: DateStyle is Postgres with European conventions
QUERY: INSERT INTO DATETIME_TBL VALUES('13/06/1957');
QUERY: SELECT count(*) as one FROM DATETIME_TBL WHERE d1 = 'Jun 13 1957';
SHOW DateStyle;
INSERT INTO DATETIME_TBL VALUES('13/06/1957');
SELECT count(*) as one FROM DATETIME_TBL WHERE d1 = 'Jun 13 1957';
one
---
-----
2
(1 row)
QUERY: SELECT '' AS sixty_three, d1 AS european_postgres FROM DATETIME_TBL;
SELECT '' AS sixty_three, d1 AS european_postgres FROM DATETIME_TBL;
sixty_three | european_postgres
-----------+-------------------------------
-------------+---------------------------------
| invalid
| -infinity
| infinity
@ -1359,9 +1402,9 @@ sixty_three|european_postgres
| Thu 13 Jun 00:00:00 1957 PDT
(63 rows)
QUERY: SELECT '' AS eight, f1 AS european_postgres FROM ABSTIME_TBL;
SELECT '' AS eight, f1 AS european_postgres FROM ABSTIME_TBL;
eight | european_postgres
-----+----------------------------
-------+------------------------------
| Sun 14 Jan 03:14:21 1973 PST
| Mon 01 May 00:30:30 1995 PDT
| epoch
@ -1372,12 +1415,12 @@ eight|european_postgres
| invalid
(8 rows)
QUERY: SET DateStyle TO 'European,ISO';
QUERY: SHOW DateStyle;
SET DateStyle TO 'European,ISO';
NOTICE: DateStyle is ISO with European conventions
QUERY: SELECT '' AS sixty_three, d1 AS european_iso FROM DATETIME_TBL;
SHOW DateStyle;
SELECT '' AS sixty_three, d1 AS european_iso FROM DATETIME_TBL;
sixty_three | european_iso
-----------+-------------------------
-------------+---------------------------
| invalid
| -infinity
| infinity
@ -1443,9 +1486,9 @@ sixty_three|european_iso
| 1957-06-13 00:00:00-07
(63 rows)
QUERY: SELECT '' AS eight, f1 AS european_iso FROM ABSTIME_TBL;
SELECT '' AS eight, f1 AS european_iso FROM ABSTIME_TBL;
eight | european_iso
-----+----------------------
-------+------------------------
| 1973-01-14 03:14:21-08
| 1995-05-01 00:30:30-07
| epoch
@ -1456,12 +1499,12 @@ eight|european_iso
| invalid
(8 rows)
QUERY: SET DateStyle TO 'European,SQL';
QUERY: SHOW DateStyle;
SET DateStyle TO 'European,SQL';
NOTICE: DateStyle is SQL with European conventions
QUERY: SELECT '' AS sixty_three, d1 AS european_sql FROM DATETIME_TBL;
SHOW DateStyle;
SELECT '' AS sixty_three, d1 AS european_sql FROM DATETIME_TBL;
sixty_three | european_sql
-----------+--------------------------
-------------+----------------------------
| invalid
| -infinity
| infinity
@ -1527,9 +1570,9 @@ sixty_three|european_sql
| 13/06/1957 00:00:00.00 PDT
(63 rows)
QUERY: SELECT '' AS eight, f1 AS european_sql FROM ABSTIME_TBL;
SELECT '' AS eight, f1 AS european_sql FROM ABSTIME_TBL;
eight | european_sql
-----+--------------------------
-------+----------------------------
| 14/01/1973 03:14:21.00 PST
| 01/05/1995 00:30:30.00 PDT
| epoch
@ -1540,6 +1583,6 @@ eight|european_sql
| invalid
(8 rows)
QUERY: RESET DateStyle;
QUERY: SHOW DateStyle;
RESET DateStyle;
NOTICE: DateStyle is Postgres with US (NonEuropean) conventions
SHOW DateStyle;

61
src/test/regress/expected/inet.out
View File

@ -1,19 +1,23 @@
QUERY: DROP TABLE INET_TBL;
--
-- INET
--
-- prepare the table...
DROP TABLE INET_TBL;
ERROR: Relation 'inet_tbl' does not exist
QUERY: CREATE TABLE INET_TBL (c cidr, i inet);
QUERY: INSERT INTO INET_TBL (c, i) VALUES ('192.168.1', '192.168.1.226/24');
QUERY: INSERT INTO INET_TBL (c, i) VALUES ('192.168.1.2/24', '192.168.1.226');
QUERY: INSERT INTO INET_TBL (c, i) VALUES ('10', '10.1.2.3/8');
QUERY: INSERT INTO INET_TBL (c, i) VALUES ('10.0.0.0', '10.1.2.3/8');
QUERY: INSERT INTO INET_TBL (c, i) VALUES ('10.1.2.3', '10.1.2.3/32');
QUERY: INSERT INTO INET_TBL (c, i) VALUES ('10.1.2', '10.1.2.3/24');
QUERY: INSERT INTO INET_TBL (c, i) VALUES ('10.1', '10.1.2.3/16');
QUERY: INSERT INTO INET_TBL (c, i) VALUES ('10', '10.1.2.3/8');
QUERY: INSERT INTO INET_TBL (c, i) VALUES ('10', '11.1.2.3/8');
QUERY: INSERT INTO INET_TBL (c, i) VALUES ('10', '9.1.2.3/8');
QUERY: SELECT '' AS ten, c AS cidr, i AS inet FROM INET_TBL;
CREATE TABLE INET_TBL (c cidr, i inet);
INSERT INTO INET_TBL (c, i) VALUES ('192.168.1', '192.168.1.226/24');
INSERT INTO INET_TBL (c, i) VALUES ('192.168.1.2/24', '192.168.1.226');
INSERT INTO INET_TBL (c, i) VALUES ('10', '10.1.2.3/8');
INSERT INTO INET_TBL (c, i) VALUES ('10.0.0.0', '10.1.2.3/8');
INSERT INTO INET_TBL (c, i) VALUES ('10.1.2.3', '10.1.2.3/32');
INSERT INTO INET_TBL (c, i) VALUES ('10.1.2', '10.1.2.3/24');
INSERT INTO INET_TBL (c, i) VALUES ('10.1', '10.1.2.3/16');
INSERT INTO INET_TBL (c, i) VALUES ('10', '10.1.2.3/8');
INSERT INTO INET_TBL (c, i) VALUES ('10', '11.1.2.3/8');
INSERT INTO INET_TBL (c, i) VALUES ('10', '9.1.2.3/8');
SELECT '' AS ten, c AS cidr, i AS inet FROM INET_TBL;
ten | cidr | inet
---+------------+----------------
-----+--------------+------------------
| 192.168.1/24 | 192.168.1.226/24
| 192.168.1/24 | 192.168.1.226
| 10/8 | 10.1.2.3/8
@ -26,9 +30,10 @@ ten|cidr |inet
| 10/8 | 9.1.2.3/8
(10 rows)
QUERY: SELECT '' AS ten, i AS inet, host(i) FROM INET_TBL;
-- now test some support functions
SELECT '' AS ten, i AS inet, host(i) FROM INET_TBL;
ten | inet | host
---+----------------+-------------
-----+------------------+---------------
| 192.168.1.226/24 | 192.168.1.226
| 192.168.1.226 | 192.168.1.226
| 10.1.2.3/8 | 10.1.2.3
@ -41,10 +46,10 @@ ten|inet | host
| 9.1.2.3/8 | 9.1.2.3
(10 rows)
QUERY: SELECT '' AS ten, c AS cidr, broadcast(c),
SELECT '' AS ten, c AS cidr, broadcast(c),
i AS inet, broadcast(i) FROM INET_TBL;
ten | cidr | broadcast | inet | broadcast
---+------------+---------------+----------------+---------------
-----+--------------+-----------------+------------------+-----------------
| 192.168.1/24 | 192.168.1.255 | 192.168.1.226/24 | 192.168.1.255
| 192.168.1/24 | 192.168.1.255 | 192.168.1.226 | 255.255.255.255
| 10/8 | 10.255.255.255 | 10.1.2.3/8 | 10.255.255.255
@ -57,10 +62,10 @@ ten|cidr | broadcast|inet | broadcast
| 10/8 | 10.255.255.255 | 9.1.2.3/8 | 9.255.255.255
(10 rows)
QUERY: SELECT '' AS ten, c AS cidr, network(c) AS "network(cidr)",
SELECT '' AS ten, c AS cidr, network(c) AS "network(cidr)",
i AS inet, network(i) AS "network(inet)" FROM INET_TBL;
ten | cidr | network(cidr) | inet | network(inet)
---+------------+-------------+----------------+----------------
-----+--------------+---------------+------------------+------------------
| 192.168.1/24 | 192.168.1/24 | 192.168.1.226/24 | 192.168.1/24
| 192.168.1/24 | 192.168.1/24 | 192.168.1.226 | 192.168.1.226/32
| 10/8 | 10/8 | 10.1.2.3/8 | 10/8
@ -73,10 +78,10 @@ ten|cidr |network(cidr)|inet |network(inet)
| 10/8 | 10/8 | 9.1.2.3/8 | 9/8
(10 rows)
QUERY: SELECT '' AS ten, c AS cidr, masklen(c) AS "masklen(cidr)",
SELECT '' AS ten, c AS cidr, masklen(c) AS "masklen(cidr)",
i AS inet, masklen(i) AS "masklen(inet)" FROM INET_TBL;
ten | cidr | masklen(cidr) | inet | masklen(inet)
---+------------+-------------+----------------+-------------
-----+--------------+---------------+------------------+---------------
| 192.168.1/24 | 24 | 192.168.1.226/24 | 24
| 192.168.1/24 | 24 | 192.168.1.226 | 32
| 10/8 | 8 | 10.1.2.3/8 | 8
@ -89,21 +94,21 @@ ten|cidr |masklen(cidr)|inet |masklen(inet)
| 10/8 | 8 | 9.1.2.3/8 | 8
(10 rows)
QUERY: SELECT '' AS four, c AS cidr, masklen(c) AS "masklen(cidr)",
SELECT '' AS four, c AS cidr, masklen(c) AS "masklen(cidr)",
i AS inet, masklen(i) AS "masklen(inet)" FROM INET_TBL
WHERE masklen(c) <= 8;
four | cidr | masklen(cidr) | inet | masklen(inet)
----+----+-------------+----------+-------------
------+------+---------------+------------+---------------
| 10/8 | 8 | 10.1.2.3/8 | 8
| 10/8 | 8 | 10.1.2.3/8 | 8
| 10/8 | 8 | 11.1.2.3/8 | 8
| 10/8 | 8 | 9.1.2.3/8 | 8
(4 rows)
QUERY: SELECT '' AS six, c AS cidr, i AS inet FROM INET_TBL
SELECT '' AS six, c AS cidr, i AS inet FROM INET_TBL
WHERE c = i;
six | cidr | inet
---+------------+----------------
-----+--------------+------------------
| 192.168.1/24 | 192.168.1.226/24
| 10/8 | 10.1.2.3/8
| 10.1.2.3/32 | 10.1.2.3
@ -112,14 +117,14 @@ six|cidr |inet
| 10/8 | 10.1.2.3/8
(6 rows)
QUERY: SELECT '' AS ten, i, c,
SELECT '' AS ten, i, c,
i < c AS lt, i <= c AS le, i = c AS eq,
i >= c AS ge, i > c AS gt, i <> c AS ne,
i << c AS sb, i <<= c AS sbe,
i >> c AS sup, i >>= c AS spe
FROM INET_TBL;
ten | i | c | lt | le | eq | ge | gt | ne | sb | sbe | sup | spe
---+----------------+------------+--+--+--+--+--+--+--+---+---+---
-----+------------------+--------------+----+----+----+----+----+----+----+-----+-----+-----
| 192.168.1.226/24 | 192.168.1/24 | f | t | t | t | f | f | f | t | f | t
| 192.168.1.226 | 192.168.1/24 | f | f | f | t | t | t | t | t | f | f
| 10.1.2.3/8 | 10/8 | f | t | t | t | f | f | f | t | f | t

38
src/test/regress/expected/lseg.out
View File

@ -1,20 +1,26 @@
QUERY: CREATE TABLE LSEG_TBL (s lseg);
QUERY: INSERT INTO LSEG_TBL VALUES ('[(1,2),(3,4)]');
QUERY: INSERT INTO LSEG_TBL VALUES ('(0,0),(6,6)');
QUERY: INSERT INTO LSEG_TBL VALUES ('10,-10 ,-3,-4');
QUERY: INSERT INTO LSEG_TBL VALUES ('[-1e6,2e2,3e5, -4e1]');
QUERY: INSERT INTO LSEG_TBL VALUES ('(11,22,33,44)');
QUERY: INSERT INTO LSEG_TBL VALUES ('(3asdf,2 ,3,4r2)');
--
-- LSEG
-- Line segments
--
--DROP TABLE LSEG_TBL;
CREATE TABLE LSEG_TBL (s lseg);
INSERT INTO LSEG_TBL VALUES ('[(1,2),(3,4)]');
INSERT INTO LSEG_TBL VALUES ('(0,0),(6,6)');
INSERT INTO LSEG_TBL VALUES ('10,-10 ,-3,-4');
INSERT INTO LSEG_TBL VALUES ('[-1e6,2e2,3e5, -4e1]');
INSERT INTO LSEG_TBL VALUES ('(11,22,33,44)');
-- bad values for parser testing
INSERT INTO LSEG_TBL VALUES ('(3asdf,2 ,3,4r2)');
ERROR: Bad lseg external representation '(3asdf,2 ,3,4r2)'
QUERY: INSERT INTO LSEG_TBL VALUES ('[1,2,3, 4');
INSERT INTO LSEG_TBL VALUES ('[1,2,3, 4');
ERROR: Bad lseg external representation '[1,2,3, 4'
QUERY: INSERT INTO LSEG_TBL VALUES ('[(,2),(3,4)]');
INSERT INTO LSEG_TBL VALUES ('[(,2),(3,4)]');
ERROR: Bad lseg external representation '[(,2),(3,4)]'
QUERY: INSERT INTO LSEG_TBL VALUES ('[(1,2),(3,4)');
INSERT INTO LSEG_TBL VALUES ('[(1,2),(3,4)');
ERROR: Bad lseg external representation '[(1,2),(3,4)'
QUERY: select * from LSEG_TBL;
select * from LSEG_TBL;
s
-----------------------------
-------------------------------
[(1,2),(3,4)]
[(0,0),(6,6)]
[(10,-10),(-3,-4)]
@ -22,15 +28,15 @@ s
[(11,22),(33,44)]
(5 rows)
QUERY: SELECT * FROM LSEG_TBL WHERE s <= '[(1,2),(3,4)]'::lseg;
SELECT * FROM LSEG_TBL WHERE s <= lseg '[(1,2),(3,4)]';
s
-------------
---------------
[(1,2),(3,4)]
(1 row)
QUERY: SELECT * FROM LSEG_TBL WHERE (s <-> '[(1,2),(3,4)]'::lseg) < 10;
SELECT * FROM LSEG_TBL WHERE (s <-> lseg '[(1,2),(3,4)]') < 10;
s
------------------
--------------------
[(1,2),(3,4)]
[(0,0),(6,6)]
[(10,-10),(-3,-4)]

1109
src/test/regress/expected/numeric.out
View File

File diff suppressed because it is too large Load Diff

78
src/test/regress/expected/numerology.out
View File

@ -1,12 +1,21 @@
QUERY: CREATE TABLE TEMP_FLOAT (f1 FLOAT8);
QUERY: INSERT INTO TEMP_FLOAT (f1)
--
-- NUMEROLOGY
-- Test various combinations of numeric types and functions.
--
--
-- Test implicit type conversions
-- This fails for Postgres v6.1 (and earlier?)
-- so let's try explicit conversions for now - tgl 97/05/07
--
CREATE TABLE TEMP_FLOAT (f1 FLOAT8);
INSERT INTO TEMP_FLOAT (f1)
SELECT float8(f1) FROM INT4_TBL;
QUERY: INSERT INTO TEMP_FLOAT (f1)
INSERT INTO TEMP_FLOAT (f1)
SELECT float8(f1) FROM INT2_TBL;
QUERY: SELECT '' AS ten, f1 FROM TEMP_FLOAT
SELECT '' AS ten, f1 FROM TEMP_FLOAT
ORDER BY f1;
ten | f1
---+-----------
-----+-------------
| -2147483647
| -123456
| -32767
@ -19,16 +28,17 @@ ten| f1
| 2147483647
(10 rows)
QUERY: CREATE TABLE TEMP_INT4 (f1 INT4);
QUERY: INSERT INTO TEMP_INT4 (f1)
-- int4
CREATE TABLE TEMP_INT4 (f1 INT4);
INSERT INTO TEMP_INT4 (f1)
SELECT int4(f1) FROM FLOAT8_TBL
WHERE (f1 > -2147483647) AND (f1 < 2147483647);
QUERY: INSERT INTO TEMP_INT4 (f1)
INSERT INTO TEMP_INT4 (f1)
SELECT int4(f1) FROM INT2_TBL;
QUERY: SELECT '' AS nine, f1 FROM TEMP_INT4
SELECT '' AS nine, f1 FROM TEMP_INT4
ORDER BY f1;
nine | f1
----+------
------+--------
| -32767
| -1234
| -1004
@ -40,17 +50,18 @@ nine| f1
| 32767
(9 rows)
QUERY: CREATE TABLE TEMP_INT2 (f1 INT2);
QUERY: INSERT INTO TEMP_INT2 (f1)
-- int2
CREATE TABLE TEMP_INT2 (f1 INT2);
INSERT INTO TEMP_INT2 (f1)
SELECT int2(f1) FROM FLOAT8_TBL
WHERE (f1 >= -32767) AND (f1 <= 32767);
QUERY: INSERT INTO TEMP_INT2 (f1)
INSERT INTO TEMP_INT2 (f1)
SELECT int2(f1) FROM INT4_TBL
WHERE (f1 >= -32767) AND (f1 <= 32767);
QUERY: SELECT '' AS five, f1 FROM TEMP_INT2
SELECT '' AS five, f1 FROM TEMP_INT2
ORDER BY f1;
five | f1
----+-----
------+-------
| -1004
| -35
| 0
@ -58,61 +69,64 @@ five| f1
| 0
(5 rows)
QUERY: CREATE TABLE TEMP_GROUP (f1 INT4, f2 INT4, f3 FLOAT8);
QUERY: INSERT INTO TEMP_GROUP
--
-- Group-by combinations
--
CREATE TABLE TEMP_GROUP (f1 INT4, f2 INT4, f3 FLOAT8);
INSERT INTO TEMP_GROUP
SELECT 1, (- i.f1), (- f.f1)
FROM INT4_TBL i, FLOAT8_TBL f;
QUERY: INSERT INTO TEMP_GROUP
INSERT INTO TEMP_GROUP
SELECT 2, i.f1, f.f1
FROM INT4_TBL i, FLOAT8_TBL f;
QUERY: SELECT DISTINCT f1 AS two FROM TEMP_GROUP;
SELECT DISTINCT f1 AS two FROM TEMP_GROUP;
two
---
-----
1
2
(2 rows)
QUERY: SELECT f1 AS two, max(f3) AS max_float, min(f3) as min_float
SELECT f1 AS two, max(f3) AS max_float, min(f3) as min_float
FROM TEMP_GROUP
GROUP BY two
ORDER BY two, max_float, min_float;
two | max_float | min_float
---+--------------------+---------------------
-----+----------------------+-----------------------
1 | 1.2345678901234e+200 | 0
2 | 0 | -1.2345678901234e+200
(2 rows)
QUERY: SELECT f1 AS two, max(f3) AS max_float, min(f3) AS min_float
SELECT f1 AS two, max(f3) AS max_float, min(f3) AS min_float
FROM TEMP_GROUP
GROUP BY two
ORDER BY two, max_float, min_float;
two | max_float | min_float
---+--------------------+---------------------
-----+----------------------+-----------------------
1 | 1.2345678901234e+200 | 0
2 | 0 | -1.2345678901234e+200
(2 rows)
QUERY: SELECT f1 AS two, (max(f3) + 1) AS max_plus_1, (min(f3) - 1) AS min_minus_1
SELECT f1 AS two, (max(f3) + 1) AS max_plus_1, (min(f3) - 1) AS min_minus_1
FROM TEMP_GROUP
GROUP BY two
ORDER BY two, min_minus_1;
two | max_plus_1 | min_minus_1
---+--------------------+---------------------
-----+----------------------+-----------------------
1 | 1.2345678901234e+200 | -1
2 | 1 | -1.2345678901234e+200
(2 rows)
QUERY: SELECT f1 AS two, (max(f3) + 1) AS max_plus_1, (min(f3) - 1) AS min_minus_1
SELECT f1 AS two, (max(f3) + 1) AS max_plus_1, (min(f3) - 1) AS min_minus_1
FROM TEMP_GROUP
GROUP BY two
ORDER BY two, min_minus_1;
two | max_plus_1 | min_minus_1
---+--------------------+---------------------
-----+----------------------+-----------------------
1 | 1.2345678901234e+200 | -1
2 | 1 | -1.2345678901234e+200
(2 rows)
QUERY: DROP TABLE TEMP_INT2;
QUERY: DROP TABLE TEMP_INT4;
QUERY: DROP TABLE TEMP_FLOAT;
QUERY: DROP TABLE TEMP_GROUP;
DROP TABLE TEMP_INT2;
DROP TABLE TEMP_INT4;
DROP TABLE TEMP_FLOAT;
DROP TABLE TEMP_GROUP;

204
src/test/regress/expected/oidjoins.out
View File

@ -1,400 +1,404 @@
QUERY: SELECT oid, pg_aggregate.aggtransfn1
--
-- OIDJOIN
-- This is created by pgsql/contrib/findoidjoins/make_oidjoin_check
--
SELECT oid, pg_aggregate.aggtransfn1
FROM pg_aggregate
WHERE pg_aggregate.aggtransfn1 != 0 AND
NOT EXISTS(SELECT * FROM pg_proc AS t1 WHERE t1.oid = pg_aggregate.aggtransfn1);
oid | aggtransfn1
---+-----------
-----+-------------
(0 rows)
QUERY: SELECT oid, pg_aggregate.aggtransfn2
SELECT oid, pg_aggregate.aggtransfn2
FROM pg_aggregate
WHERE pg_aggregate.aggtransfn2 != 0 AND
NOT EXISTS(SELECT * FROM pg_proc AS t1 WHERE t1.oid = pg_aggregate.aggtransfn2);
oid | aggtransfn2
---+-----------
-----+-------------
(0 rows)
QUERY: SELECT oid, pg_aggregate.aggfinalfn
SELECT oid, pg_aggregate.aggfinalfn
FROM pg_aggregate
WHERE pg_aggregate.aggfinalfn != 0 AND
NOT EXISTS(SELECT * FROM pg_proc AS t1 WHERE t1.oid = pg_aggregate.aggfinalfn);
oid | aggfinalfn
---+----------
-----+------------
(0 rows)
QUERY: SELECT oid, pg_aggregate.aggbasetype
SELECT oid, pg_aggregate.aggbasetype
FROM pg_aggregate
WHERE pg_aggregate.aggbasetype != 0 AND
NOT EXISTS(SELECT * FROM pg_type AS t1 WHERE t1.oid = pg_aggregate.aggbasetype);
oid | aggbasetype
---+-----------
-----+-------------
(0 rows)
QUERY: SELECT oid, pg_aggregate.aggtranstype1
SELECT oid, pg_aggregate.aggtranstype1
FROM pg_aggregate
WHERE pg_aggregate.aggtranstype1 != 0 AND
NOT EXISTS(SELECT * FROM pg_type AS t1 WHERE t1.oid = pg_aggregate.aggtranstype1);
oid | aggtranstype1
---+-------------
-----+---------------
(0 rows)
QUERY: SELECT oid, pg_aggregate.aggtranstype2
SELECT oid, pg_aggregate.aggtranstype2
FROM pg_aggregate
WHERE pg_aggregate.aggtranstype2 != 0 AND
NOT EXISTS(SELECT * FROM pg_type AS t1 WHERE t1.oid = pg_aggregate.aggtranstype2);
oid | aggtranstype2
---+-------------
-----+---------------
(0 rows)
QUERY: SELECT oid, pg_aggregate.aggfinaltype
SELECT oid, pg_aggregate.aggfinaltype
FROM pg_aggregate
WHERE pg_aggregate.aggfinaltype != 0 AND
NOT EXISTS(SELECT * FROM pg_type AS t1 WHERE t1.oid = pg_aggregate.aggfinaltype);
oid | aggfinaltype
---+------------
-----+--------------
(0 rows)
QUERY: SELECT oid, pg_am.amgettuple
SELECT oid, pg_am.amgettuple
FROM pg_am
WHERE pg_am.amgettuple != 0 AND
NOT EXISTS(SELECT * FROM pg_proc AS t1 WHERE t1.oid = pg_am.amgettuple);
oid | amgettuple
---+----------
-----+------------
(0 rows)
QUERY: SELECT oid, pg_am.aminsert
SELECT oid, pg_am.aminsert
FROM pg_am
WHERE pg_am.aminsert != 0 AND
NOT EXISTS(SELECT * FROM pg_proc AS t1 WHERE t1.oid = pg_am.aminsert);
oid | aminsert
---+--------
-----+----------
(0 rows)
QUERY: SELECT oid, pg_am.amdelete
SELECT oid, pg_am.amdelete
FROM pg_am
WHERE pg_am.amdelete != 0 AND
NOT EXISTS(SELECT * FROM pg_proc AS t1 WHERE t1.oid = pg_am.amdelete);
oid | amdelete
---+--------
-----+----------
(0 rows)
QUERY: SELECT oid, pg_am.ambeginscan
SELECT oid, pg_am.ambeginscan
FROM pg_am
WHERE pg_am.ambeginscan != 0 AND
NOT EXISTS(SELECT * FROM pg_proc AS t1 WHERE t1.oid = pg_am.ambeginscan);
oid | ambeginscan
---+-----------
-----+-------------
(0 rows)
QUERY: SELECT oid, pg_am.amrescan
SELECT oid, pg_am.amrescan
FROM pg_am
WHERE pg_am.amrescan != 0 AND
NOT EXISTS(SELECT * FROM pg_proc AS t1 WHERE t1.oid = pg_am.amrescan);
oid | amrescan
---+--------
-----+----------
(0 rows)
QUERY: SELECT oid, pg_am.amendscan
SELECT oid, pg_am.amendscan
FROM pg_am
WHERE pg_am.amendscan != 0 AND
NOT EXISTS(SELECT * FROM pg_proc AS t1 WHERE t1.oid = pg_am.amendscan);
oid | amendscan
---+---------
-----+-----------
(0 rows)
QUERY: SELECT oid, pg_am.ammarkpos
SELECT oid, pg_am.ammarkpos
FROM pg_am
WHERE pg_am.ammarkpos != 0 AND
NOT EXISTS(SELECT * FROM pg_proc AS t1 WHERE t1.oid = pg_am.ammarkpos);
oid | ammarkpos
---+---------
-----+-----------
(0 rows)
QUERY: SELECT oid, pg_am.amrestrpos
SELECT oid, pg_am.amrestrpos
FROM pg_am
WHERE pg_am.amrestrpos != 0 AND
NOT EXISTS(SELECT * FROM pg_proc AS t1 WHERE t1.oid = pg_am.amrestrpos);
oid | amrestrpos
---+----------
-----+------------
(0 rows)
QUERY: SELECT oid, pg_am.ambuild
SELECT oid, pg_am.ambuild
FROM pg_am
WHERE pg_am.ambuild != 0 AND
NOT EXISTS(SELECT * FROM pg_proc AS t1 WHERE t1.oid = pg_am.ambuild);
oid | ambuild
---+-------
-----+---------
(0 rows)
QUERY: SELECT oid, pg_amop.amopid
SELECT oid, pg_amop.amopid
FROM pg_amop
WHERE pg_amop.amopid != 0 AND
NOT EXISTS(SELECT * FROM pg_am AS t1 WHERE t1.oid = pg_amop.amopid);
oid | amopid
---+------
-----+--------
(0 rows)
QUERY: SELECT oid, pg_amop.amopclaid
SELECT oid, pg_amop.amopclaid
FROM pg_amop
WHERE pg_amop.amopclaid != 0 AND
NOT EXISTS(SELECT * FROM pg_opclass AS t1 WHERE t1.oid = pg_amop.amopclaid);
oid | amopclaid
---+---------
-----+-----------
(0 rows)
QUERY: SELECT oid, pg_amop.amopopr
SELECT oid, pg_amop.amopopr
FROM pg_amop
WHERE pg_amop.amopopr != 0 AND
NOT EXISTS(SELECT * FROM pg_operator AS t1 WHERE t1.oid = pg_amop.amopopr);
oid | amopopr
---+-------
-----+---------
(0 rows)
QUERY: SELECT oid, pg_amop.amopselect
SELECT oid, pg_amop.amopselect
FROM pg_amop
WHERE pg_amop.amopselect != 0 AND
NOT EXISTS(SELECT * FROM pg_proc AS t1 WHERE t1.oid = pg_amop.amopselect);
oid | amopselect
---+----------
-----+------------
(0 rows)
QUERY: SELECT oid, pg_amop.amopnpages
SELECT oid, pg_amop.amopnpages
FROM pg_amop
WHERE pg_amop.amopnpages != 0 AND
NOT EXISTS(SELECT * FROM pg_proc AS t1 WHERE t1.oid = pg_amop.amopnpages);
oid | amopnpages
---+----------
-----+------------
(0 rows)
QUERY: SELECT oid, pg_amproc.amid
SELECT oid, pg_amproc.amid
FROM pg_amproc
WHERE pg_amproc.amid != 0 AND
NOT EXISTS(SELECT * FROM pg_am AS t1 WHERE t1.oid = pg_amproc.amid);
oid | amid
---+----
-----+------
(0 rows)
QUERY: SELECT oid, pg_amproc.amopclaid
SELECT oid, pg_amproc.amopclaid
FROM pg_amproc
WHERE pg_amproc.amopclaid != 0 AND
NOT EXISTS(SELECT * FROM pg_opclass AS t1 WHERE t1.oid = pg_amproc.amopclaid);
oid | amopclaid
---+---------
-----+-----------
(0 rows)
QUERY: SELECT oid, pg_amproc.amproc
SELECT oid, pg_amproc.amproc
FROM pg_amproc
WHERE pg_amproc.amproc != 0 AND
NOT EXISTS(SELECT * FROM pg_proc AS t1 WHERE t1.oid = pg_amproc.amproc);
oid | amproc
---+------
-----+--------
(0 rows)
QUERY: SELECT oid, pg_attribute.attrelid
SELECT oid, pg_attribute.attrelid
FROM pg_attribute
WHERE pg_attribute.attrelid != 0 AND
NOT EXISTS(SELECT * FROM pg_class AS t1 WHERE t1.oid = pg_attribute.attrelid);
oid | attrelid
---+--------
-----+----------
(0 rows)
QUERY: SELECT oid, pg_attribute.atttypid
SELECT oid, pg_attribute.atttypid
FROM pg_attribute
WHERE pg_attribute.atttypid != 0 AND
NOT EXISTS(SELECT * FROM pg_type AS t1 WHERE t1.oid = pg_attribute.atttypid);
oid | atttypid
---+--------
-----+----------
(0 rows)
QUERY: SELECT oid, pg_class.reltype
SELECT oid, pg_class.reltype
FROM pg_class
WHERE pg_class.reltype != 0 AND
NOT EXISTS(SELECT * FROM pg_type AS t1 WHERE t1.oid = pg_class.reltype);
oid | reltype
---+-------
-----+---------
(0 rows)
QUERY: SELECT oid, pg_class.relam
SELECT oid, pg_class.relam
FROM pg_class
WHERE pg_class.relam != 0 AND
NOT EXISTS(SELECT * FROM pg_am AS t1 WHERE t1.oid = pg_class.relam);
oid | relam
---+-----
-----+-------
(0 rows)
QUERY: SELECT oid, pg_index.indexrelid
SELECT oid, pg_index.indexrelid
FROM pg_index
WHERE pg_index.indexrelid != 0 AND
NOT EXISTS(SELECT * FROM pg_class AS t1 WHERE t1.oid = pg_index.indexrelid);
oid | indexrelid
---+----------
-----+------------
(0 rows)
QUERY: SELECT oid, pg_index.indrelid
SELECT oid, pg_index.indrelid
FROM pg_index
WHERE pg_index.indrelid != 0 AND
NOT EXISTS(SELECT * FROM pg_class AS t1 WHERE t1.oid = pg_index.indrelid);
oid | indrelid
---+--------
-----+----------
(0 rows)
QUERY: SELECT oid, pg_opclass.opcdeftype
SELECT oid, pg_opclass.opcdeftype
FROM pg_opclass
WHERE pg_opclass.opcdeftype != 0 AND
NOT EXISTS(SELECT * FROM pg_type AS t1 WHERE t1.oid = pg_opclass.opcdeftype);
oid | opcdeftype
---+----------
-----+------------
(0 rows)
QUERY: SELECT oid, pg_operator.oprleft
SELECT oid, pg_operator.oprleft
FROM pg_operator
WHERE pg_operator.oprleft != 0 AND
NOT EXISTS(SELECT * FROM pg_type AS t1 WHERE t1.oid = pg_operator.oprleft);
oid | oprleft
---+-------
-----+---------
(0 rows)
QUERY: SELECT oid, pg_operator.oprright
SELECT oid, pg_operator.oprright
FROM pg_operator
WHERE pg_operator.oprright != 0 AND
NOT EXISTS(SELECT * FROM pg_type AS t1 WHERE t1.oid = pg_operator.oprright);
oid | oprright
---+--------
-----+----------
(0 rows)
QUERY: SELECT oid, pg_operator.oprresult
SELECT oid, pg_operator.oprresult
FROM pg_operator
WHERE pg_operator.oprresult != 0 AND
NOT EXISTS(SELECT * FROM pg_type AS t1 WHERE t1.oid = pg_operator.oprresult);
oid | oprresult
---+---------
-----+-----------
(0 rows)
QUERY: SELECT oid, pg_operator.oprcom
SELECT oid, pg_operator.oprcom
FROM pg_operator
WHERE pg_operator.oprcom != 0 AND
NOT EXISTS(SELECT * FROM pg_operator AS t1 WHERE t1.oid = pg_operator.oprcom);
oid | oprcom
---+------
-----+--------
(0 rows)
QUERY: SELECT oid, pg_operator.oprnegate
SELECT oid, pg_operator.oprnegate
FROM pg_operator
WHERE pg_operator.oprnegate != 0 AND
NOT EXISTS(SELECT * FROM pg_operator AS t1 WHERE t1.oid = pg_operator.oprnegate);
oid | oprnegate
---+---------
-----+-----------
(0 rows)
QUERY: SELECT oid, pg_operator.oprlsortop
SELECT oid, pg_operator.oprlsortop
FROM pg_operator
WHERE pg_operator.oprlsortop != 0 AND
NOT EXISTS(SELECT * FROM pg_operator AS t1 WHERE t1.oid = pg_operator.oprlsortop);
oid | oprlsortop
---+----------
-----+------------
(0 rows)
QUERY: SELECT oid, pg_operator.oprrsortop
SELECT oid, pg_operator.oprrsortop
FROM pg_operator
WHERE pg_operator.oprrsortop != 0 AND
NOT EXISTS(SELECT * FROM pg_operator AS t1 WHERE t1.oid = pg_operator.oprrsortop);
oid | oprrsortop
---+----------
-----+------------
(0 rows)
QUERY: SELECT oid, pg_operator.oprcode
SELECT oid, pg_operator.oprcode
FROM pg_operator
WHERE pg_operator.oprcode != 0 AND
NOT EXISTS(SELECT * FROM pg_proc AS t1 WHERE t1.oid = pg_operator.oprcode);
oid | oprcode
---+-------
-----+---------
(0 rows)
QUERY: SELECT oid, pg_operator.oprrest
SELECT oid, pg_operator.oprrest
FROM pg_operator
WHERE pg_operator.oprrest != 0 AND
NOT EXISTS(SELECT * FROM pg_proc AS t1 WHERE t1.oid = pg_operator.oprrest);
oid | oprrest
---+-------
-----+---------
(0 rows)
QUERY: SELECT oid, pg_operator.oprjoin
SELECT oid, pg_operator.oprjoin
FROM pg_operator
WHERE pg_operator.oprjoin != 0 AND
NOT EXISTS(SELECT * FROM pg_proc AS t1 WHERE t1.oid = pg_operator.oprjoin);
oid | oprjoin
---+-------
-----+---------
(0 rows)
QUERY: SELECT oid, pg_proc.prolang
SELECT oid, pg_proc.prolang
FROM pg_proc
WHERE pg_proc.prolang != 0 AND
NOT EXISTS(SELECT * FROM pg_language AS t1 WHERE t1.oid = pg_proc.prolang);
oid | prolang
---+-------
-----+---------
(0 rows)
QUERY: SELECT oid, pg_proc.prorettype
SELECT oid, pg_proc.prorettype
FROM pg_proc
WHERE pg_proc.prorettype != 0 AND
NOT EXISTS(SELECT * FROM pg_type AS t1 WHERE t1.oid = pg_proc.prorettype);
oid | prorettype
---+----------
-----+------------
(0 rows)
QUERY: SELECT oid, pg_rewrite.ev_class
SELECT oid, pg_rewrite.ev_class
FROM pg_rewrite
WHERE pg_rewrite.ev_class != 0 AND
NOT EXISTS(SELECT * FROM pg_class AS t1 WHERE t1.oid = pg_rewrite.ev_class);
oid | ev_class
---+--------
-----+----------
(0 rows)
QUERY: SELECT oid, pg_type.typrelid
SELECT oid, pg_type.typrelid
FROM pg_type
WHERE pg_type.typrelid != 0 AND
NOT EXISTS(SELECT * FROM pg_class AS t1 WHERE t1.oid = pg_type.typrelid);
oid | typrelid
---+--------
-----+----------
(0 rows)
QUERY: SELECT oid, pg_type.typelem
SELECT oid, pg_type.typelem
FROM pg_type
WHERE pg_type.typelem != 0 AND
NOT EXISTS(SELECT * FROM pg_type AS t1 WHERE t1.oid = pg_type.typelem);
oid | typelem
---+-------
-----+---------
(0 rows)
QUERY: SELECT oid, pg_type.typinput
SELECT oid, pg_type.typinput
FROM pg_type
WHERE pg_type.typinput != 0 AND
NOT EXISTS(SELECT * FROM pg_proc AS t1 WHERE t1.oid = pg_type.typinput);
oid | typinput
---+--------
-----+----------
(0 rows)
QUERY: SELECT oid, pg_type.typoutput
SELECT oid, pg_type.typoutput
FROM pg_type
WHERE pg_type.typoutput != 0 AND
NOT EXISTS(SELECT * FROM pg_proc AS t1 WHERE t1.oid = pg_type.typoutput);
oid | typoutput
---+---------
-----+-----------
(0 rows)
QUERY: SELECT oid, pg_type.typreceive
SELECT oid, pg_type.typreceive
FROM pg_type
WHERE pg_type.typreceive != 0 AND
NOT EXISTS(SELECT * FROM pg_proc AS t1 WHERE t1.oid = pg_type.typreceive);
oid | typreceive
---+----------
-----+------------
(0 rows)
QUERY: SELECT oid, pg_type.typsend
SELECT oid, pg_type.typsend
FROM pg_type
WHERE pg_type.typsend != 0 AND
NOT EXISTS(SELECT * FROM pg_proc AS t1 WHERE t1.oid = pg_type.typsend);
oid | typsend
---+-------
-----+---------
(0 rows)

351
src/test/regress/expected/opr_sanity.out
View File

@ -1,4 +1,27 @@
QUERY: SELECT p1.oid, p1.proname
--
-- OPR_SANITY
-- Sanity checks for common errors in making operator/procedure system tables:
-- pg_operator, pg_proc, pg_aggregate, pg_am, pg_amop, pg_amproc, pg_opclass.
--
-- None of the SELECTs here should ever find any matching entries,
-- so the expected output is easy to maintain ;-).
-- A test failure indicates someone messed up an entry in the system tables.
--
-- NB: we assume the oidjoins test will have caught any dangling links,
-- that is OID or REGPROC fields that are not zero and do not match some
-- row in the linked-to table. However, if we want to enforce that a link
-- field can't be 0, we have to check it here.
--
-- NB: run this test earlier than the create_operator test, because
-- that test creates some bogus operators...
--
-- NOTE hardwired assumptions about standard types:
-- type bool has OID 16
-- type float8 has OID 701
--
-- **************** pg_proc ****************
-- Look for illegal values in pg_proc fields.
SELECT p1.oid, p1.proname
FROM pg_proc as p1
WHERE (p1.prolang = 0 OR p1.prorettype = 0 OR
p1.pronargs < 0 OR p1.pronargs > 9)
@ -6,20 +29,26 @@ WHERE (p1.prolang = 0 OR p1.prorettype = 0 OR
AND p1.proname !~ '^RI_FKey_'
AND p1.proname != 'update_pg_pwd';
oid | proname
---+-------
-----+---------
(0 rows)
QUERY: SELECT p1.oid, p1.proname, p2.oid, p2.proname
-- Look for conflicting proc definitions (same names and input datatypes).
SELECT p1.oid, p1.proname, p2.oid, p2.proname
FROM pg_proc AS p1, pg_proc AS p2
WHERE p1.oid != p2.oid AND
p1.proname = p2.proname AND
p1.pronargs = p2.pronargs AND
p1.proargtypes = p2.proargtypes;
oid | proname | oid | proname
---+-------+---+-------
-----+---------+-----+---------
(0 rows)
QUERY: SELECT p1.oid, p1.proname, p2.oid, p2.proname
-- Considering only built-in procs (prolang = 11), look for multiple uses
-- of the same internal function (ie, matching prosrc fields). It's OK to
-- have several entries with different pronames for the same internal function,
-- but conflicts in the number of arguments and other critical items should
-- be complained of.
SELECT p1.oid, p1.proname, p2.oid, p2.proname
FROM pg_proc AS p1, pg_proc AS p2
WHERE p1.oid != p2.oid AND
p1.prosrc = p2.prosrc AND p1.prolang = 11 AND p2.prolang = 11 AND
@ -29,113 +58,123 @@ WHERE p1.oid != p2.oid AND
p1.pronargs != p2.pronargs OR
p1.proretset != p2.proretset);
oid | proname | oid | proname
---+-------+---+-------
-----+---------+-----+---------
(0 rows)
QUERY: SELECT DISTINCT p1.prorettype, p2.prorettype
-- Look for uses of different type OIDs in the argument/result type fields
-- for different aliases of the same built-in function.
-- This indicates that the types are being presumed to be binary-equivalent.
-- That's not wrong, necessarily, but we make lists of all the types being
-- so treated. Note that the expected output of this part of the test will
-- need to be modified whenever new pairs of types are made binary-equivalent!
SELECT DISTINCT p1.prorettype, p2.prorettype
FROM pg_proc AS p1, pg_proc AS p2
WHERE p1.oid != p2.oid AND
p1.prosrc = p2.prosrc AND p1.prolang = 11 AND p2.prolang = 11 AND
(p1.prorettype < p2.prorettype);
prorettype | prorettype
----------+----------
------------+------------
18 | 25
25 | 1043
(2 rows)
QUERY: SELECT DISTINCT p1.proargtypes[0], p2.proargtypes[0]
SELECT DISTINCT p1.proargtypes[0], p2.proargtypes[0]
FROM pg_proc AS p1, pg_proc AS p2
WHERE p1.oid != p2.oid AND
p1.prosrc = p2.prosrc AND p1.prolang = 11 AND p2.prolang = 11 AND
(p1.proargtypes[0] < p2.proargtypes[0]);
proargtypes | proargtypes
-----------+-----------
-------------+-------------
25 | 1043
1042 | 1043
(2 rows)
QUERY: SELECT DISTINCT p1.proargtypes[1], p2.proargtypes[1]
SELECT DISTINCT p1.proargtypes[1], p2.proargtypes[1]
FROM pg_proc AS p1, pg_proc AS p2
WHERE p1.oid != p2.oid AND
p1.prosrc = p2.prosrc AND p1.prolang = 11 AND p2.prolang = 11 AND
(p1.proargtypes[1] < p2.proargtypes[1]);
proargtypes | proargtypes
-----------+-----------
-------------+-------------
(0 rows)
QUERY: SELECT DISTINCT p1.proargtypes[2], p2.proargtypes[2]
SELECT DISTINCT p1.proargtypes[2], p2.proargtypes[2]
FROM pg_proc AS p1, pg_proc AS p2
WHERE p1.oid != p2.oid AND
p1.prosrc = p2.prosrc AND p1.prolang = 11 AND p2.prolang = 11 AND
(p1.proargtypes[2] < p2.proargtypes[2]);
proargtypes | proargtypes
-----------+-----------
-------------+-------------
(0 rows)
QUERY: SELECT DISTINCT p1.proargtypes[3], p2.proargtypes[3]
SELECT DISTINCT p1.proargtypes[3], p2.proargtypes[3]
FROM pg_proc AS p1, pg_proc AS p2
WHERE p1.oid != p2.oid AND
p1.prosrc = p2.prosrc AND p1.prolang = 11 AND p2.prolang = 11 AND
(p1.proargtypes[3] < p2.proargtypes[3]);
proargtypes | proargtypes
-----------+-----------
-------------+-------------
(0 rows)
QUERY: SELECT DISTINCT p1.proargtypes[4], p2.proargtypes[4]
SELECT DISTINCT p1.proargtypes[4], p2.proargtypes[4]
FROM pg_proc AS p1, pg_proc AS p2
WHERE p1.oid != p2.oid AND
p1.prosrc = p2.prosrc AND p1.prolang = 11 AND p2.prolang = 11 AND
(p1.proargtypes[4] < p2.proargtypes[4]);
proargtypes | proargtypes
-----------+-----------
-------------+-------------
(0 rows)
QUERY: SELECT DISTINCT p1.proargtypes[5], p2.proargtypes[5]
SELECT DISTINCT p1.proargtypes[5], p2.proargtypes[5]
FROM pg_proc AS p1, pg_proc AS p2
WHERE p1.oid != p2.oid AND
p1.prosrc = p2.prosrc AND p1.prolang = 11 AND p2.prolang = 11 AND
(p1.proargtypes[5] < p2.proargtypes[5]);
proargtypes | proargtypes
-----------+-----------
-------------+-------------
(0 rows)
QUERY: SELECT DISTINCT p1.proargtypes[6], p2.proargtypes[6]
SELECT DISTINCT p1.proargtypes[6], p2.proargtypes[6]
FROM pg_proc AS p1, pg_proc AS p2
WHERE p1.oid != p2.oid AND
p1.prosrc = p2.prosrc AND p1.prolang = 11 AND p2.prolang = 11 AND
(p1.proargtypes[6] < p2.proargtypes[6]);
proargtypes | proargtypes
-----------+-----------
-------------+-------------
(0 rows)
QUERY: SELECT DISTINCT p1.proargtypes[7], p2.proargtypes[7]
SELECT DISTINCT p1.proargtypes[7], p2.proargtypes[7]
FROM pg_proc AS p1, pg_proc AS p2
WHERE p1.oid != p2.oid AND
p1.prosrc = p2.prosrc AND p1.prolang = 11 AND p2.prolang = 11 AND
(p1.proargtypes[7] < p2.proargtypes[7]);
proargtypes | proargtypes
-----------+-----------
-------------+-------------
(0 rows)
QUERY: SELECT p1.oid, p1.oprname
-- **************** pg_operator ****************
-- Look for illegal values in pg_operator fields.
SELECT p1.oid, p1.oprname
FROM pg_operator as p1
WHERE (p1.oprkind != 'b' AND p1.oprkind != 'l' AND p1.oprkind != 'r') OR
p1.oprresult = 0 OR p1.oprcode = 0;
oid | oprname
---+-------
-----+---------
(0 rows)
QUERY: SELECT p1.oid, p1.oprname
-- Look for missing or unwanted operand types
SELECT p1.oid, p1.oprname
FROM pg_operator as p1
WHERE (p1.oprleft = 0 and p1.oprkind != 'l') OR
(p1.oprleft != 0 and p1.oprkind = 'l') OR
(p1.oprright = 0 and p1.oprkind != 'r') OR
(p1.oprright != 0 and p1.oprkind = 'r');
oid | oprname
---+-------
-----+---------
(0 rows)
QUERY: SELECT p1.oid, p1.oprcode, p2.oid, p2.oprcode
-- Look for conflicting operator definitions (same names and input datatypes).
SELECT p1.oid, p1.oprcode, p2.oid, p2.oprcode
FROM pg_operator AS p1, pg_operator AS p2
WHERE p1.oid != p2.oid AND
p1.oprname = p2.oprname AND
@ -143,10 +182,14 @@ WHERE p1.oid != p2.oid AND
p1.oprleft = p2.oprleft AND
p1.oprright = p2.oprright;
oid | oprcode | oid | oprcode
---+-------+---+-------
-----+---------+-----+---------
(0 rows)
QUERY: SELECT p1.oid, p1.oprcode, p2.oid, p2.oprcode
-- Look for commutative operators that don't commute.
-- DEFINITIONAL NOTE: If A.oprcom = B, then x A y has the same result as y B x.
-- We expect that B will always say that B.oprcom = A as well; that's not
-- inherently essential, but it would be inefficient not to mark it so.
SELECT p1.oid, p1.oprcode, p2.oid, p2.oprcode
FROM pg_operator AS p1, pg_operator AS p2
WHERE p1.oprcom = p2.oid AND
(p1.oprkind != 'b' OR
@ -155,10 +198,16 @@ WHERE p1.oprcom = p2.oid AND
p1.oprresult != p2.oprresult OR
p1.oid != p2.oprcom);
oid | oprcode | oid | oprcode
---+-------+---+-------
-----+---------+-----+---------
(0 rows)
QUERY: SELECT p1.oid, p1.oprcode, p2.oid, p2.oprcode
-- Look for negatory operators that don't agree.
-- DEFINITIONAL NOTE: If A.oprnegate = B, then both A and B must yield
-- boolean results, and (x A y) == ! (x B y), or the equivalent for
-- single-operand operators.
-- We expect that B will always say that B.oprnegate = A as well; that's not
-- inherently essential, but it would be inefficient not to mark it so.
SELECT p1.oid, p1.oprcode, p2.oid, p2.oprcode
FROM pg_operator AS p1, pg_operator AS p2
WHERE p1.oprnegate = p2.oid AND
(p1.oprkind != p2.oprkind OR
@ -168,10 +217,14 @@ WHERE p1.oprnegate = p2.oid AND
p2.oprresult != 16 OR
p1.oid != p2.oprnegate);
oid | oprcode | oid | oprcode
---+-------+---+-------
-----+---------+-----+---------
(0 rows)
QUERY: SELECT p1.oid, p1.oprcode, p2.oid, p2.oprcode
-- Look for mergejoin operators that don't match their links.
-- A mergejoin link leads from an '=' operator to the
-- sort operator ('<' operator) that's appropriate for
-- its left-side or right-side data type.
SELECT p1.oid, p1.oprcode, p2.oid, p2.oprcode
FROM pg_operator AS p1, pg_operator AS p2
WHERE p1.oprlsortop = p2.oid AND
(p1.oprname != '=' OR p2.oprname != '<' OR
@ -182,10 +235,10 @@ WHERE p1.oprlsortop = p2.oid AND
p2.oprresult != 16 OR
p1.oprrsortop = 0);
oid | oprcode | oid | oprcode
---+-------+---+-------
-----+---------+-----+---------
(0 rows)
QUERY: SELECT p1.oid, p1.oprcode, p2.oid, p2.oprcode
SELECT p1.oid, p1.oprcode, p2.oid, p2.oprcode
FROM pg_operator AS p1, pg_operator AS p2
WHERE p1.oprrsortop = p2.oid AND
(p1.oprname != '=' OR p2.oprname != '<' OR
@ -196,17 +249,22 @@ WHERE p1.oprrsortop = p2.oid AND
p2.oprresult != 16 OR
p1.oprlsortop = 0);
oid | oprcode | oid | oprcode
---+-------+---+-------
-----+---------+-----+---------
(0 rows)
QUERY: SELECT p1.oid, p1.oprname FROM pg_operator AS p1
-- A mergejoinable = operator must have a commutator (usually itself)
-- as well as corresponding < and > operators. Note that the "corresponding"
-- operators have the same L and R input datatypes as the = operator,
-- whereas the operators linked to by oprlsortop and oprrsortop have input
-- datatypes L,L and R,R respectively.
SELECT p1.oid, p1.oprname FROM pg_operator AS p1
WHERE p1.oprlsortop != 0 AND
p1.oprcom = 0;
oid | oprname
---+-------
-----+---------
(0 rows)
QUERY: SELECT p1.oid, p1.oprname FROM pg_operator AS p1
SELECT p1.oid, p1.oprname FROM pg_operator AS p1
WHERE p1.oprlsortop != 0 AND NOT
EXISTS(SELECT * FROM pg_operator AS p2 WHERE
p2.oprname = '<' AND
@ -214,10 +272,10 @@ WHERE p1.oprlsortop != 0 AND NOT
p2.oprright = p1.oprright AND
p2.oprkind = 'b');
oid | oprname
---+-------
-----+---------
(0 rows)
QUERY: SELECT p1.oid, p1.oprname FROM pg_operator AS p1
SELECT p1.oid, p1.oprname FROM pg_operator AS p1
WHERE p1.oprlsortop != 0 AND NOT
EXISTS(SELECT * FROM pg_operator AS p2 WHERE
p2.oprname = '>' AND
@ -225,38 +283,72 @@ WHERE p1.oprlsortop != 0 AND NOT
p2.oprright = p1.oprright AND
p2.oprkind = 'b');
oid | oprname
---+-------
-----+---------
(0 rows)
QUERY: SELECT p1.oid, p1.oprname
-- Hashing only works on simple equality operators "type = sametype",
-- since the hash itself depends on the bitwise representation of the type.
-- Check that allegedly hashable operators look like they might be "=".
-- NOTE: in 6.5, this search finds int4eqoid and oideqint4. Until we have
-- some cleaner way of dealing with binary-equivalent types, just leave
-- those two tuples in the expected output.
SELECT p1.oid, p1.oprname
FROM pg_operator AS p1
WHERE p1.oprcanhash AND NOT
(p1.oprkind = 'b' AND p1.oprresult = 16 AND p1.oprleft = p1.oprright AND
p1.oprname = '=' AND p1.oprcom = p1.oid);
oid | oprname
----+-------
------+---------
1136 | =
1137 | =
(2 rows)
QUERY: SELECT p1.oid, p1.oprname
-- In 6.5 we accepted hashable array equality operators when the array element
-- type is hashable. However, what we actually need to make hashjoin work on
-- an array is a hashable element type *and* no padding between elements in
-- the array storage (or, perhaps, guaranteed-zero padding). Currently,
-- since the padding code in arrayfuncs.c is pretty bogus, it seems safest
-- to just forbid hashjoin on array equality ops.
-- This should be reconsidered someday.
-- -- Look for array equality operators that are hashable when the underlying
-- -- type is not, or vice versa. This is presumably bogus.
--
-- SELECT p1.oid, p1.oprcanhash, p2.oid, p2.oprcanhash, t1.typname, t2.typname
-- FROM pg_operator AS p1, pg_operator AS p2, pg_type AS t1, pg_type AS t2
-- WHERE p1.oprname = '=' AND p1.oprleft = p1.oprright AND
-- p2.oprname = '=' AND p2.oprleft = p2.oprright AND
-- p1.oprleft = t1.oid AND p2.oprleft = t2.oid AND t1.typelem = t2.oid AND
-- p1.oprcanhash != p2.oprcanhash;
-- Substitute check: forbid hashable array ops, period.
SELECT p1.oid, p1.oprname
FROM pg_operator AS p1, pg_proc AS p2
WHERE p1.oprcanhash AND p1.oprcode = p2.oid AND p2.proname = 'array_eq';
oid | oprname
---+-------
-----+---------
(0 rows)
QUERY: SELECT p1.oid, p1.oprname, p2.oid, p2.proname
-- Check that each operator defined in pg_operator matches its oprcode entry
-- in pg_proc. Easiest to do this separately for each oprkind.
-- FIXME: want to check that argument/result types match, but how to do that
-- in the face of binary-compatible types?
SELECT p1.oid, p1.oprname, p2.oid, p2.proname
FROM pg_operator AS p1, pg_proc AS p2
WHERE p1.oprcode = p2.oid AND
p1.oprkind = 'b' AND
(p2.pronargs != 2
-- diked out until we find a way of marking binary-compatible types
-- OR
-- p1.oprresult != p2.prorettype OR
-- (p1.oprleft != p2.proargtypes[0] AND p2.proargtypes[0] != 0) OR
-- (p1.oprright != p2.proargtypes[1] AND p2.proargtypes[1] != 0)
);
oid | oprname | oid | proname
---+-------+---+-------
-----+---------+-----+---------
(0 rows)
QUERY: SELECT p1.oid, p1.oprname, p2.oid, p2.proname
-- These two selects can be left as-is because there are no binary-compatible
-- cases that they trip over, at least in 6.5:
SELECT p1.oid, p1.oprname, p2.oid, p2.proname
FROM pg_operator AS p1, pg_proc AS p2
WHERE p1.oprcode = p2.oid AND
p1.oprkind = 'l' AND
@ -265,10 +357,10 @@ WHERE p1.oprcode = p2.oid AND
(p1.oprright != p2.proargtypes[0] AND p2.proargtypes[0] != 0) OR
p1.oprleft != 0);
oid | oprname | oid | proname
---+-------+---+-------
-----+---------+-----+---------
(0 rows)
QUERY: SELECT p1.oid, p1.oprname, p2.oid, p2.proname
SELECT p1.oid, p1.oprname, p2.oid, p2.proname
FROM pg_operator AS p1, pg_proc AS p2
WHERE p1.oprcode = p2.oid AND
p1.oprkind = 'r' AND
@ -277,10 +369,14 @@ WHERE p1.oprcode = p2.oid AND
(p1.oprleft != p2.proargtypes[0] AND p2.proargtypes[0] != 0) OR
p1.oprright != 0);
oid | oprname | oid | proname
---+-------+---+-------
-----+---------+-----+---------
(0 rows)
QUERY: SELECT p1.oid, p1.oprname, p2.oid, p2.proname
-- If oprrest is set, the operator must return boolean,
-- and it must link to a proc with the right signature
-- to be a restriction selectivity estimator.
-- The proc signature we want is: float8 proc(oid, oid, int2, <any>, int4)
SELECT p1.oid, p1.oprname, p2.oid, p2.proname
FROM pg_operator AS p1, pg_proc AS p2
WHERE p1.oprrest = p2.oid AND
(p1.oprresult != 16 OR
@ -290,10 +386,14 @@ WHERE p1.oprrest = p2.oid AND
p2.proargtypes[2] != 21 OR p2.proargtypes[3] != 0 OR
p2.proargtypes[4] != 23);
oid | oprname | oid | proname
---+-------+---+-------
-----+---------+-----+---------
(0 rows)
QUERY: SELECT p1.oid, p1.oprname, p2.oid, p2.proname
-- If oprjoin is set, the operator must be a binary boolean op,
-- and it must link to a proc with the right signature
-- to be a join selectivity estimator.
-- The proc signature we want is: float8 proc(oid, oid, int2, oid, int2)
SELECT p1.oid, p1.oprname, p2.oid, p2.proname
FROM pg_operator AS p1, pg_proc AS p2
WHERE p1.oprjoin = p2.oid AND
(p1.oprkind != 'b' OR p1.oprresult != 16 OR
@ -303,70 +403,92 @@ WHERE p1.oprjoin = p2.oid AND
p2.proargtypes[2] != 21 OR p2.proargtypes[3] != 26 OR
p2.proargtypes[4] != 21);
oid | oprname | oid | proname
---+-------+---+-------
-----+---------+-----+---------
(0 rows)
QUERY: SELECT p1.oid, p1.aggname
-- **************** pg_aggregate ****************
-- Look for illegal values in pg_aggregate fields.
-- aggbasetype can only be 0 if transfn1 is not present (eg, count(*))
-- or itself takes a wild-card input; we check the latter case below.
SELECT p1.oid, p1.aggname
FROM pg_aggregate as p1
WHERE (p1.aggbasetype = 0 AND p1.aggtransfn1 != 0) OR aggfinaltype = 0;
oid | aggname
---+-------
-----+---------
(0 rows)
QUERY: SELECT p1.oid, p1.aggname
-- Check combinations of transfer functions.
-- Although either transfn1 or transfn2 can be null,
-- it makes no sense for both to be. And if both are defined,
-- presumably there should be a finalfn to combine their results.
-- We also check that transtypes are null just when corresponding
-- transfns are. Also, if there is no finalfn then the output type
-- must be the transtype the result will be taken from.
SELECT p1.oid, p1.aggname
FROM pg_aggregate as p1
WHERE p1.aggtransfn1 = 0 AND p1.aggtransfn2 = 0;
oid | aggname
---+-------
-----+---------
(0 rows)
QUERY: SELECT p1.oid, p1.aggname
SELECT p1.oid, p1.aggname
FROM pg_aggregate as p1
WHERE p1.aggtransfn1 != 0 AND p1.aggtransfn2 = 0 AND
(p1.aggtranstype1 = 0 OR p1.aggtranstype2 != 0 OR
(p1.aggfinalfn = 0 AND p1.aggfinaltype != p1.aggtranstype1));
oid | aggname
---+-------
-----+---------
(0 rows)
QUERY: SELECT p1.oid, p1.aggname
SELECT p1.oid, p1.aggname
FROM pg_aggregate as p1
WHERE p1.aggtransfn1 = 0 AND p1.aggtransfn2 != 0 AND
(p1.aggtranstype1 != 0 OR p1.aggtranstype2 = 0 OR
(p1.aggfinalfn = 0 AND p1.aggfinaltype != p1.aggtranstype2));
oid | aggname
---+-------
-----+---------
(0 rows)
QUERY: SELECT p1.oid, p1.aggname
SELECT p1.oid, p1.aggname
FROM pg_aggregate as p1
WHERE p1.aggtransfn1 != 0 AND p1.aggtransfn2 != 0 AND
(p1.aggtranstype1 = 0 OR p1.aggtranstype2 = 0 OR
p1.aggfinalfn = 0);
oid | aggname
---+-------
-----+---------
(0 rows)
QUERY: SELECT p1.oid, p1.aggname, p2.oid, p2.proname
-- Cross-check transfn1 (if present) against its entry in pg_proc.
-- FIXME: what about binary-compatible types?
SELECT p1.oid, p1.aggname, p2.oid, p2.proname
FROM pg_aggregate AS p1, pg_proc AS p2
WHERE p1.aggtransfn1 = p2.oid AND
(p2.proretset OR p2.pronargs != 2
-- diked out until we find a way of marking binary-compatible types
-- OR
-- p1.aggtranstype1 != p2.prorettype OR
-- p1.aggtranstype1 != p2.proargtypes[0] OR
-- p1.aggbasetype != p2.proargtypes[1]
);
oid | aggname | oid | proname
---+-------+---+-------
-----+---------+-----+---------
(0 rows)
QUERY: SELECT p1.oid, p1.aggname, p2.oid, p2.proname
-- Cross-check transfn2 (if present) against its entry in pg_proc.
-- FIXME: what about binary-compatible types?
SELECT p1.oid, p1.aggname, p2.oid, p2.proname
FROM pg_aggregate AS p1, pg_proc AS p2
WHERE p1.aggtransfn2 = p2.oid AND
(p2.proretset OR p1.aggtranstype2 != p2.prorettype OR
p2.pronargs != 1 OR
p1.aggtranstype2 != p2.proargtypes[0]);
oid | aggname | oid | proname
---+-------+---+-------
-----+---------+-----+---------
(0 rows)
QUERY: SELECT p1.oid, p1.aggname, p2.oid, p2.proname
-- Cross-check finalfn (if present) against its entry in pg_proc.
-- FIXME: what about binary-compatible types?
SELECT p1.oid, p1.aggname, p2.oid, p2.proname
FROM pg_aggregate AS p1, pg_proc AS p2
WHERE p1.aggfinalfn = p2.oid AND
(p2.proretset OR p1.aggfinaltype != p2.prorettype OR
@ -374,62 +496,75 @@ WHERE p1.aggfinalfn = p2.oid AND
p1.aggtranstype1 != p2.proargtypes[0] OR
p1.aggtranstype2 != p2.proargtypes[1]);
oid | aggname | oid | proname
---+-------+---+-------
-----+---------+-----+---------
(0 rows)
QUERY: SELECT p1.oid
-- **************** pg_amop ****************
-- Look for illegal values in pg_amop fields
SELECT p1.oid
FROM pg_amop as p1
WHERE p1.amopid = 0 OR p1.amopclaid = 0 OR p1.amopopr = 0 OR
p1.amopstrategy <= 0 OR p1.amopselect = 0 OR p1.amopnpages = 0;
oid
---
-----
(0 rows)
QUERY: SELECT p1.oid, p2.oid
-- Look for duplicate pg_amop entries
SELECT p1.oid, p2.oid
FROM pg_amop AS p1, pg_amop AS p2
WHERE p1.oid != p2.oid AND
p1.amopid = p2.amopid AND
p1.amopclaid = p2.amopclaid AND
p1.amopstrategy = p2.amopstrategy;
oid | oid
---+---
-----+-----
(0 rows)
QUERY: SELECT p1.oid, p2.oid, p2.amname
-- Cross-check amopstrategy index against parent AM
SELECT p1.oid, p2.oid, p2.amname
FROM pg_amop AS p1, pg_am AS p2
WHERE p1.amopid = p2.oid AND p1.amopstrategy > p2.amstrategies;
oid | oid | amname
---+---+------
-----+-----+--------
(0 rows)
QUERY: SELECT p1.oid, p1.amname, p2.oid, p2.opcname
-- Detect missing pg_amop entries: should have as many strategy functions
-- as AM expects for each opclass, unless there are none at all
-- (some opclasses only offer support for a limited set of AMs...)
SELECT p1.oid, p1.amname, p2.oid, p2.opcname
FROM pg_am AS p1, pg_opclass AS p2
WHERE p1.amstrategies != (SELECT count(*) FROM pg_amop AS p3
WHERE p3.amopid = p1.oid AND p3.amopclaid = p2.oid)
AND EXISTS (SELECT * FROM pg_amop AS p3
WHERE p3.amopid = p1.oid AND p3.amopclaid = p2.oid);
oid | amname | oid | opcname
---+------+---+-------
-----+--------+-----+---------
(0 rows)
QUERY: SELECT p1.oid, p2.oid, p2.oprname
-- Check that amopopr points at a reasonable-looking operator
SELECT p1.oid, p2.oid, p2.oprname
FROM pg_amop AS p1, pg_operator AS p2
WHERE p1.amopopr = p2.oid AND
(p2.oprkind != 'b' OR p2.oprresult != 16);
oid | oid | oprname
---+---+-------
-----+-----+---------
(0 rows)
QUERY: SELECT p1.oid, p2.oid, p2.oprname, p3.oid, p3.opcname
-- If opclass is for a specific type, operator inputs should be of that type
SELECT p1.oid, p2.oid, p2.oprname, p3.oid, p3.opcname
FROM pg_amop AS p1, pg_operator AS p2, pg_opclass AS p3
WHERE p1.amopopr = p2.oid AND p1.amopclaid = p3.oid AND
p3.opcdeftype != 0 AND
(p3.opcdeftype != p2.oprleft OR p3.opcdeftype != p2.oprright);
oid | oid | oprname | oid | opcname
---+---+-------+---+-------
-----+-----+---------+-----+---------
(0 rows)
QUERY: SELECT p1.oid, p2.oid, p2.proname
-- Check that amopselect points to a proc with the right signature
-- to be an access-method selectivity estimator.
-- The proc signature we want is:
-- float8 proc(oid, oid, int2, <any>, int4, int4, oid)
SELECT p1.oid, p2.oid, p2.proname
FROM pg_amop AS p1, pg_proc AS p2
WHERE p1.amopselect = p2.oid AND
(p2.prorettype != 701 OR p2.proretset OR
@ -439,10 +574,14 @@ WHERE p1.amopselect = p2.oid AND
p2.proargtypes[4] != 23 OR p2.proargtypes[5] != 23 OR
p2.proargtypes[6] != 26);
oid | oid | proname
---+---+-------
-----+-----+---------
(0 rows)
QUERY: SELECT p1.oid, p2.oid, p2.proname
-- Check that amopnpages points to a proc with the right signature
-- to be an access-method page-count estimator.
-- The proc signature we want is:
-- float8 proc(oid, oid, int2, <any>, int4, int4, oid)
SELECT p1.oid, p2.oid, p2.proname
FROM pg_amop AS p1, pg_proc AS p2
WHERE p1.amopnpages = p2.oid AND
(p2.prorettype != 701 OR p2.proretset OR
@ -452,51 +591,63 @@ WHERE p1.amopnpages = p2.oid AND
p2.proargtypes[4] != 23 OR p2.proargtypes[5] != 23 OR
p2.proargtypes[6] != 26);
oid | oid | proname
---+---+-------
-----+-----+---------
(0 rows)
QUERY: SELECT p1.oid
-- **************** pg_amproc ****************
-- Look for illegal values in pg_amproc fields
SELECT p1.oid
FROM pg_amproc as p1
WHERE p1.amid = 0 OR p1.amopclaid = 0 OR p1.amproc = 0 OR
p1.amprocnum <= 0;
oid
---
-----
(0 rows)
QUERY: SELECT p1.oid, p2.oid
-- Look for duplicate pg_amproc entries
SELECT p1.oid, p2.oid
FROM pg_amproc AS p1, pg_amproc AS p2
WHERE p1.oid != p2.oid AND
p1.amid = p2.amid AND
p1.amopclaid = p2.amopclaid AND
p1.amprocnum = p2.amprocnum;
oid | oid
---+---
-----+-----
(0 rows)
QUERY: SELECT p1.oid, p2.oid, p2.amname
-- Cross-check amprocnum index against parent AM
SELECT p1.oid, p2.oid, p2.amname
FROM pg_amproc AS p1, pg_am AS p2
WHERE p1.amid = p2.oid AND p1.amprocnum > p2.amsupport;
oid | oid | amname
---+---+------
-----+-----+--------
(0 rows)
QUERY: SELECT p1.oid, p1.amname, p2.oid, p2.opcname
-- Detect missing pg_amproc entries: should have as many support functions
-- as AM expects for each opclass, unless there are none at all
-- (some opclasses only offer support for a limited set of AMs...)
SELECT p1.oid, p1.amname, p2.oid, p2.opcname
FROM pg_am AS p1, pg_opclass AS p2
WHERE p1.amsupport != (SELECT count(*) FROM pg_amproc AS p3
WHERE p3.amid = p1.oid AND p3.amopclaid = p2.oid)
AND EXISTS (SELECT * FROM pg_amproc AS p3
WHERE p3.amid = p1.oid AND p3.amopclaid = p2.oid);
oid | amname | oid | opcname
---+------+---+-------
-----+--------+-----+---------
(0 rows)
QUERY: SELECT p1.oid, p2.oid, p2.proname, p3.oid, p4.oid, p4.proname
-- Unfortunately, we can't check the amproc link very well because the
-- signature of the function may be different for different support routines
-- or different base data types.
-- We can check that all the referenced instances of the same support
-- routine number take the same number of parameters, but that's about it...
SELECT p1.oid, p2.oid, p2.proname, p3.oid, p4.oid, p4.proname
FROM pg_amproc AS p1, pg_proc AS p2, pg_amproc AS p3, pg_proc AS p4
WHERE p1.oid != p3.oid AND
p1.amid = p3.amid AND p1.amprocnum = p3.amprocnum AND
p1.amproc = p2.oid AND p3.amproc = p4.oid AND
(p2.proretset OR p4.proretset OR p2.pronargs != p4.pronargs);
oid | oid | proname | oid | oid | proname
---+---+-------+---+---+-------
-----+-----+---------+-----+-----+---------
(0 rows)

47
src/test/regress/expected/path.out
View File

@ -1,19 +1,24 @@
QUERY: CREATE TABLE PATH_TBL (f1 path);
QUERY: INSERT INTO PATH_TBL VALUES ('[(1,2),(3,4)]');
QUERY: INSERT INTO PATH_TBL VALUES ('((1,2),(3,4))');
QUERY: INSERT INTO PATH_TBL VALUES ('[(0,0),(3,0),(4,5),(1,6)]');
QUERY: INSERT INTO PATH_TBL VALUES ('((1,2),(3,4))');
QUERY: INSERT INTO PATH_TBL VALUES ('1,2 ,3,4');
QUERY: INSERT INTO PATH_TBL VALUES ('[1,2,3, 4]');
QUERY: INSERT INTO PATH_TBL VALUES ('[11,12,13,14]');
QUERY: INSERT INTO PATH_TBL VALUES ('(11,12,13,14)');
QUERY: INSERT INTO PATH_TBL VALUES ('[(,2),(3,4)]');
--
-- PATH
--
--DROP TABLE PATH_TBL;
CREATE TABLE PATH_TBL (f1 path);
INSERT INTO PATH_TBL VALUES ('[(1,2),(3,4)]');
INSERT INTO PATH_TBL VALUES ('((1,2),(3,4))');
INSERT INTO PATH_TBL VALUES ('[(0,0),(3,0),(4,5),(1,6)]');
INSERT INTO PATH_TBL VALUES ('((1,2),(3,4))');
INSERT INTO PATH_TBL VALUES ('1,2 ,3,4');
INSERT INTO PATH_TBL VALUES ('[1,2,3, 4]');
INSERT INTO PATH_TBL VALUES ('[11,12,13,14]');
INSERT INTO PATH_TBL VALUES ('(11,12,13,14)');
-- bad values for parser testing
INSERT INTO PATH_TBL VALUES ('[(,2),(3,4)]');
ERROR: Bad path external representation '[(,2),(3,4)]'
QUERY: INSERT INTO PATH_TBL VALUES ('[(1,2),(3,4)');
INSERT INTO PATH_TBL VALUES ('[(1,2),(3,4)');
ERROR: Bad path external representation '[(1,2),(3,4)'
QUERY: SELECT f1 FROM PATH_TBL;
SELECT f1 FROM PATH_TBL;
f1
-------------------------
---------------------------
[(1,2),(3,4)]
((1,2),(3,4))
[(0,0),(3,0),(4,5),(1,6)]
@ -24,27 +29,27 @@ f1
((11,12),(13,14))
(8 rows)
QUERY: SELECT '' AS count, f1 AS open_path FROM PATH_TBL WHERE isopen(f1);
SELECT '' AS count, f1 AS open_path FROM PATH_TBL WHERE isopen(f1);
count | open_path
-----+-------------------------
-------+---------------------------
| [(1,2),(3,4)]
| [(0,0),(3,0),(4,5),(1,6)]
| [(1,2),(3,4)]
| [(11,12),(13,14)]
(4 rows)
QUERY: SELECT '' AS count, f1 AS closed_path FROM PATH_TBL WHERE isclosed(f1);
SELECT '' AS count, f1 AS closed_path FROM PATH_TBL WHERE isclosed(f1);
count | closed_path
-----+-----------------
-------+-------------------
| ((1,2),(3,4))
| ((1,2),(3,4))
| ((1,2),(3,4))
| ((11,12),(13,14))
(4 rows)
QUERY: SELECT '' AS count, pclose(f1) AS closed_path FROM PATH_TBL;
SELECT '' AS count, pclose(f1) AS closed_path FROM PATH_TBL;
count | closed_path
-----+-------------------------
-------+---------------------------
| ((1,2),(3,4))
| ((1,2),(3,4))
| ((0,0),(3,0),(4,5),(1,6))
@ -55,9 +60,9 @@ count|closed_path
| ((11,12),(13,14))
(8 rows)
QUERY: SELECT '' AS count, popen(f1) AS open_path FROM PATH_TBL;
SELECT '' AS count, popen(f1) AS open_path FROM PATH_TBL;
count | open_path
-----+-------------------------
-------+---------------------------
| [(1,2),(3,4)]
| [(1,2),(3,4)]
| [(0,0),(3,0),(4,5),(1,6)]

98
src/test/regress/expected/point.out
View File

@ -1,19 +1,23 @@
QUERY: CREATE TABLE POINT_TBL(f1 point);
QUERY: INSERT INTO POINT_TBL(f1) VALUES ('(0.0,0.0)');
QUERY: INSERT INTO POINT_TBL(f1) VALUES ('(-10.0,0.0)');
QUERY: INSERT INTO POINT_TBL(f1) VALUES ('(-3.0,4.0)');
QUERY: INSERT INTO POINT_TBL(f1) VALUES ('(5.1, 34.5)');
QUERY: INSERT INTO POINT_TBL(f1) VALUES ('(-5.0,-12.0)');
QUERY: INSERT INTO POINT_TBL(f1) VALUES ('asdfasdf');
--
-- POINT
--
CREATE TABLE POINT_TBL(f1 point);
INSERT INTO POINT_TBL(f1) VALUES ('(0.0,0.0)');
INSERT INTO POINT_TBL(f1) VALUES ('(-10.0,0.0)');
INSERT INTO POINT_TBL(f1) VALUES ('(-3.0,4.0)');
INSERT INTO POINT_TBL(f1) VALUES ('(5.1, 34.5)');
INSERT INTO POINT_TBL(f1) VALUES ('(-5.0,-12.0)');
-- bad format points
INSERT INTO POINT_TBL(f1) VALUES ('asdfasdf');
ERROR: Bad point external representation 'asdfasdf'
QUERY: INSERT INTO POINT_TBL(f1) VALUES ('10.0,10.0');
QUERY: INSERT INTO POINT_TBL(f1) VALUES ('(10.0 10.0)');
INSERT INTO POINT_TBL(f1) VALUES ('10.0,10.0');
INSERT INTO POINT_TBL(f1) VALUES ('(10.0 10.0)');
ERROR: Bad point external representation '(10.0 10.0)'
QUERY: INSERT INTO POINT_TBL(f1) VALUES ('(10.0,10.0');
INSERT INTO POINT_TBL(f1) VALUES ('(10.0,10.0');
ERROR: Bad point external representation '(10.0,10.0'
QUERY: SELECT '' AS six, POINT_TBL.*;
SELECT '' AS six, POINT_TBL.*;
six | f1
---+----------
-----+------------
| (0,0)
| (-10,0)
| (-3,4)
@ -22,71 +26,77 @@ six|f1
| (10,10)
(6 rows)
QUERY: SELECT '' AS three, p.* FROM POINT_TBL p WHERE p.f1 << '(0.0, 0.0)';
-- left of
SELECT '' AS three, p.* FROM POINT_TBL p WHERE p.f1 << '(0.0, 0.0)';
three | f1
-----+--------
-------+----------
| (-10,0)
| (-3,4)
| (-5,-12)
(3 rows)
QUERY: SELECT '' AS three, p.* FROM POINT_TBL p WHERE '(0.0,0.0)' >> p.f1;
-- right of
SELECT '' AS three, p.* FROM POINT_TBL p WHERE '(0.0,0.0)' >> p.f1;
three | f1
-----+--------
-------+----------
| (-10,0)
| (-3,4)
| (-5,-12)
(3 rows)
QUERY: SELECT '' AS one, p.* FROM POINT_TBL p WHERE '(0.0,0.0)' >^ p.f1;
-- above
SELECT '' AS one, p.* FROM POINT_TBL p WHERE '(0.0,0.0)' >^ p.f1;
one | f1
---+--------
-----+----------
| (-5,-12)
(1 row)
QUERY: SELECT '' AS one, p.* FROM POINT_TBL p WHERE p.f1 <^ '(0.0, 0.0)';
-- below
SELECT '' AS one, p.* FROM POINT_TBL p WHERE p.f1 <^ '(0.0, 0.0)';
one | f1
---+--------
-----+----------
| (-5,-12)
(1 row)
QUERY: SELECT '' AS one, p.* FROM POINT_TBL p WHERE p.f1 ~= '(5.1, 34.5)';
-- equal
SELECT '' AS one, p.* FROM POINT_TBL p WHERE p.f1 ~= '(5.1, 34.5)';
one | f1
---+----------
-----+------------
| (5.1,34.5)
(1 row)
QUERY: SELECT '' AS three, p.* FROM POINT_TBL p
WHERE p.f1 @ '(0,0,100,100)'::box;
-- point in box
SELECT '' AS three, p.* FROM POINT_TBL p
WHERE p.f1 @ box '(0,0,100,100)';
three | f1
-----+----------
-------+------------
| (0,0)
| (5.1,34.5)
| (10,10)
(3 rows)
QUERY: SELECT '' AS three, p.* FROM POINT_TBL p
WHERE not p.f1 @ '(0,0,100,100)'::box;
SELECT '' AS three, p.* FROM POINT_TBL p
WHERE not p.f1 @ box '(0,0,100,100)';
three | f1
-----+--------
-------+----------
| (-10,0)
| (-3,4)
| (-5,-12)
(3 rows)
QUERY: SELECT '' AS two, p.* FROM POINT_TBL p
WHERE p.f1 @ '[(0,0),(-10,0),(-10,10)]'::path;
SELECT '' AS two, p.* FROM POINT_TBL p
WHERE p.f1 @ path '[(0,0),(-10,0),(-10,10)]';
two | f1
---+-------
-----+---------
| (0,0)
| (-10,0)
(2 rows)
QUERY: SELECT '' AS six, p.f1, p.f1 <-> '(0,0)'::point AS dist
SELECT '' AS six, p.f1, p.f1 <-> point '(0,0)' AS dist
FROM POINT_TBL p
ORDER BY dist;
six | f1 | dist
---+----------+----------------
-----+------------+------------------
| (0,0) | 0
| (-3,4) | 5
| (-10,0) | 10
@ -95,12 +105,12 @@ six|f1 | dist
| (5.1,34.5) | 34.8749193547455
(6 rows)
QUERY: SET geqo TO 'off';
QUERY: SELECT '' AS thirtysix, p1.f1 AS point1, p2.f1 AS point2, p1.f1 <-> p2.f1 AS dist
SET geqo TO 'off';
SELECT '' AS thirtysix, p1.f1 AS point1, p2.f1 AS point2, p1.f1 <-> p2.f1 AS dist
FROM POINT_TBL p1, POINT_TBL p2
ORDER BY dist, point1 using <<, point2 using <<;
thirtysix | point1 | point2 | dist
---------+----------+----------+----------------
-----------+------------+------------+------------------
| (-10,0) | (-10,0) | 0
| (-5,-12) | (-5,-12) | 0
| (-3,4) | (-3,4) | 0
@ -139,11 +149,11 @@ thirtysix|point1 |point2 | dist
| (5.1,34.5) | (-5,-12) | 47.5842410888311
(36 rows)
QUERY: SELECT '' AS thirty, p1.f1 AS point1, p2.f1 AS point2
SELECT '' AS thirty, p1.f1 AS point1, p2.f1 AS point2
FROM POINT_TBL p1, POINT_TBL p2
WHERE (p1.f1 <-> p2.f1) > 3;
thirty | point1 | point2
------+----------+----------
--------+------------+------------
| (-10,0) | (0,0)
| (-3,4) | (0,0)
| (5.1,34.5) | (0,0)
@ -176,12 +186,13 @@ thirty|point1 |point2
| (-5,-12) | (10,10)
(30 rows)
QUERY: SELECT '' AS fifteen, p1.f1 AS point1, p2.f1 AS point2, (p1.f1 <-> p2.f1) AS distance
-- put distance result into output to allow sorting with GEQ optimizer - tgl 97/05/10
SELECT '' AS fifteen, p1.f1 AS point1, p2.f1 AS point2, (p1.f1 <-> p2.f1) AS distance
FROM POINT_TBL p1, POINT_TBL p2
WHERE (p1.f1 <-> p2.f1) > 3 and p1.f1 << p2.f1
ORDER BY distance, point1 using <<, point2 using <<;
fifteen | point1 | point2 | distance
-------+----------+----------+----------------
---------+------------+------------+------------------
| (-3,4) | (0,0) | 5
| (-10,0) | (-3,4) | 8.06225774829855
| (-10,0) | (0,0) | 10
@ -199,15 +210,16 @@ fifteen|point1 |point2 | distance
| (-5,-12) | (5.1,34.5) | 47.5842410888311
(15 rows)
QUERY: SELECT '' AS three, p1.f1 AS point1, p2.f1 AS point2, (p1.f1 <-> p2.f1) AS distance
-- put distance result into output to allow sorting with GEQ optimizer - tgl 97/05/10
SELECT '' AS three, p1.f1 AS point1, p2.f1 AS point2, (p1.f1 <-> p2.f1) AS distance
FROM POINT_TBL p1, POINT_TBL p2
WHERE (p1.f1 <-> p2.f1) > 3 and p1.f1 << p2.f1 and p1.f1 >^ p2.f1
ORDER BY distance;
three | point1 | point2 | distance
-----+----------+--------+----------------
-------+------------+----------+------------------
| (-3,4) | (0,0) | 5
| (-10,0) | (-5,-12) | 13
| (5.1,34.5) | (10,10) | 24.9851956166046
(3 rows)
QUERY: RESET geqo;
RESET geqo;

140
src/test/regress/expected/polygon.out
View File

@ -1,141 +1,187 @@
QUERY: CREATE TABLE POLYGON_TBL(f1 polygon);
QUERY: INSERT INTO POLYGON_TBL(f1) VALUES ('(2.0,0.0),(2.0,4.0),(0.0,0.0)');
QUERY: INSERT INTO POLYGON_TBL(f1) VALUES ('(3.0,1.0),(3.0,3.0),(1.0,0.0)');
QUERY: INSERT INTO POLYGON_TBL(f1) VALUES ('(0.0,0.0)');
QUERY: INSERT INTO POLYGON_TBL(f1) VALUES ('(0.0,1.0),(0.0,1.0)');
QUERY: INSERT INTO POLYGON_TBL(f1) VALUES ('0.0');
--
-- POLYGON
--
-- polygon logic
--
-- 3 o
-- |
-- 2 + |
-- / |
-- 1 # o +
-- / |
-- 0 #-----o-+
--
-- 0 1 2 3 4
--
CREATE TABLE POLYGON_TBL(f1 polygon);
INSERT INTO POLYGON_TBL(f1) VALUES ('(2.0,0.0),(2.0,4.0),(0.0,0.0)');
INSERT INTO POLYGON_TBL(f1) VALUES ('(3.0,1.0),(3.0,3.0),(1.0,0.0)');
-- degenerate polygons
INSERT INTO POLYGON_TBL(f1) VALUES ('(0.0,0.0)');
INSERT INTO POLYGON_TBL(f1) VALUES ('(0.0,1.0),(0.0,1.0)');
-- bad polygon input strings
INSERT INTO POLYGON_TBL(f1) VALUES ('0.0');
ERROR: Bad polygon external representation '0.0'
QUERY: INSERT INTO POLYGON_TBL(f1) VALUES ('(0.0 0.0');
INSERT INTO POLYGON_TBL(f1) VALUES ('(0.0 0.0');
ERROR: Bad polygon external representation '(0.0 0.0'
QUERY: INSERT INTO POLYGON_TBL(f1) VALUES ('(0,1,2)');
INSERT INTO POLYGON_TBL(f1) VALUES ('(0,1,2)');
ERROR: Bad polygon external representation '(0,1,2)'
QUERY: INSERT INTO POLYGON_TBL(f1) VALUES ('(0,1,2,3');
INSERT INTO POLYGON_TBL(f1) VALUES ('(0,1,2,3');
ERROR: Bad polygon external representation '(0,1,2,3'
QUERY: INSERT INTO POLYGON_TBL(f1) VALUES ('asdf');
INSERT INTO POLYGON_TBL(f1) VALUES ('asdf');
ERROR: Bad polygon external representation 'asdf'
QUERY: SELECT '' AS four, POLYGON_TBL.*;
SELECT '' AS four, POLYGON_TBL.*;
four | f1
----+-------------------
------+---------------------
| ((2,0),(2,4),(0,0))
| ((3,1),(3,3),(1,0))
| ((0,0))
| ((0,1),(0,1))
(4 rows)
QUERY: SELECT '' AS three, p.*
-- overlap
SELECT '' AS three, p.*
FROM POLYGON_TBL p
WHERE p.f1 && '(3.0,1.0),(3.0,3.0),(1.0,0.0)';
three | f1
-----+-------------------
-------+---------------------
| ((2,0),(2,4),(0,0))
| ((3,1),(3,3),(1,0))
(2 rows)
QUERY: SELECT '' AS four, p.*
-- left overlap
SELECT '' AS four, p.*
FROM POLYGON_TBL p
WHERE p.f1 &< '(3.0,1.0),(3.0,3.0),(1.0,0.0)';
four | f1
----+-------------------
------+---------------------
| ((2,0),(2,4),(0,0))
| ((3,1),(3,3),(1,0))
| ((0,0))
| ((0,1),(0,1))
(4 rows)
QUERY: SELECT '' AS two, p.*
-- right overlap
SELECT '' AS two, p.*
FROM POLYGON_TBL p
WHERE p.f1 &> '(3.0,1.0),(3.0,3.0),(1.0,0.0)';
two | f1
---+-------------------
-----+---------------------
| ((2,0),(2,4),(0,0))
| ((3,1),(3,3),(1,0))
(2 rows)
QUERY: SELECT '' AS one, p.*
-- left of
SELECT '' AS one, p.*
FROM POLYGON_TBL p
WHERE p.f1 << '(3.0,1.0),(3.0,3.0),(1.0,0.0)';
one | f1
---+-------------
-----+---------------
| ((0,0))
| ((0,1),(0,1))
(2 rows)
QUERY: SELECT '' AS zero, p.*
-- right of
SELECT '' AS zero, p.*
FROM POLYGON_TBL p
WHERE p.f1 >> '(3.0,1.0),(3.0,3.0),(1.0,0.0)';
zero | f1
----+--
------+----
(0 rows)
QUERY: SELECT '' AS one, p.*
-- contained
SELECT '' AS one, p.*
FROM POLYGON_TBL p
WHERE p.f1 @ '(3.0,1.0),(3.0,3.0),(1.0,0.0)'::polygon;
WHERE p.f1 @ polygon '(3.0,1.0),(3.0,3.0),(1.0,0.0)';
one | f1
---+-------------------
-----+---------------------
| ((3,1),(3,3),(1,0))
(1 row)
QUERY: SELECT '' AS one, p.*
-- same
SELECT '' AS one, p.*
FROM POLYGON_TBL p
WHERE p.f1 ~= '(3.0,1.0),(3.0,3.0),(1.0,0.0)'::polygon;
WHERE p.f1 ~= polygon '(3.0,1.0),(3.0,3.0),(1.0,0.0)';
one | f1
---+-------------------
-----+---------------------
| ((3,1),(3,3),(1,0))
(1 row)
QUERY: SELECT '' AS one, p.*
-- contains
SELECT '' AS one, p.*
FROM POLYGON_TBL p
WHERE p.f1 ~ '(3.0,1.0),(3.0,3.0),(1.0,0.0)'::polygon;
WHERE p.f1 ~ polygon '(3.0,1.0),(3.0,3.0),(1.0,0.0)';
one | f1
---+-------------------
-----+---------------------
| ((3,1),(3,3),(1,0))
(1 row)
QUERY: SELECT '(2.0,0.0),(2.0,4.0),(0.0,0.0)'::polygon << '(3.0,1.0),(3.0,3.0),(1.0,0.0)'::polygon AS false;
--
-- polygon logic
--
-- 3 o
-- |
-- 2 + |
-- / |
-- 1 / o +
-- / |
-- 0 +-----o-+
--
-- 0 1 2 3 4
--
-- left of
SELECT polygon '(2.0,0.0),(2.0,4.0),(0.0,0.0)' << polygon '(3.0,1.0),(3.0,3.0),(1.0,0.0)' AS false;
false
-----
-------
f
(1 row)
QUERY: SELECT '(2.0,0.0),(2.0,4.0),(0.0,0.0)'::polygon << '(3.0,1.0),(3.0,3.0),(1.0,0.0)'::polygon AS true;
-- left overlap
SELECT polygon '(2.0,0.0),(2.0,4.0),(0.0,0.0)' << polygon '(3.0,1.0),(3.0,3.0),(1.0,0.0)' AS true;
true
----
------
f
(1 row)
QUERY: SELECT '(2.0,0.0),(2.0,4.0),(0.0,0.0)'::polygon &> '(3.0,1.0),(3.0,3.0),(1.0,0.0)'::polygon AS true;
-- right overlap
SELECT polygon '(2.0,0.0),(2.0,4.0),(0.0,0.0)' &> polygon '(3.0,1.0),(3.0,3.0),(1.0,0.0)' AS true;
true
----
------
t
(1 row)
QUERY: SELECT '(2.0,0.0),(2.0,4.0),(0.0,0.0)'::polygon >> '(3.0,1.0),(3.0,3.0),(1.0,0.0)'::polygon AS false;
-- right of
SELECT polygon '(2.0,0.0),(2.0,4.0),(0.0,0.0)' >> polygon '(3.0,1.0),(3.0,3.0),(1.0,0.0)' AS false;
false
-----
-------
f
(1 row)
QUERY: SELECT '(2.0,0.0),(2.0,4.0),(0.0,0.0)'::polygon @ '(3.0,1.0),(3.0,3.0),(1.0,0.0)'::polygon AS false;
-- contained in
SELECT polygon '(2.0,0.0),(2.0,4.0),(0.0,0.0)' @ polygon '(3.0,1.0),(3.0,3.0),(1.0,0.0)' AS false;
false
-----
-------
f
(1 row)
QUERY: SELECT '(2.0,0.0),(2.0,4.0),(0.0,0.0)'::polygon ~ '(3.0,1.0),(3.0,3.0),(1.0,0.0)'::polygon AS false;
-- contains
SELECT polygon '(2.0,0.0),(2.0,4.0),(0.0,0.0)' ~ polygon '(3.0,1.0),(3.0,3.0),(1.0,0.0)' AS false;
false
-----
-------
f
(1 row)
QUERY: SELECT '(2.0,0.0),(2.0,4.0),(0.0,0.0)'::polygon ~= '(3.0,1.0),(3.0,3.0),(1.0,0.0)'::polygon AS false;
-- same
SELECT polygon '(2.0,0.0),(2.0,4.0),(0.0,0.0)' ~= polygon '(3.0,1.0),(3.0,3.0),(1.0,0.0)' AS false;
false
-----
-------
f
(1 row)
QUERY: SELECT '(2.0,0.0),(2.0,4.0),(0.0,0.0)'::polygon && '(3.0,1.0),(3.0,3.0),(1.0,0.0)'::polygon AS true;
-- overlap
SELECT polygon '(2.0,0.0),(2.0,4.0),(0.0,0.0)' && polygon '(3.0,1.0),(3.0,3.0),(1.0,0.0)' AS true;
true
----
------
t
(1 row)

67
src/test/regress/expected/reltime.out
View File

@ -1,17 +1,22 @@
QUERY: CREATE TABLE RELTIME_TBL (f1 reltime);
QUERY: INSERT INTO RELTIME_TBL (f1) VALUES ('@ 1 minute');
QUERY: INSERT INTO RELTIME_TBL (f1) VALUES ('@ 5 hour');
QUERY: INSERT INTO RELTIME_TBL (f1) VALUES ('@ 10 day');
QUERY: INSERT INTO RELTIME_TBL (f1) VALUES ('@ 34 year');
QUERY: INSERT INTO RELTIME_TBL (f1) VALUES ('@ 3 months');
QUERY: INSERT INTO RELTIME_TBL (f1) VALUES ('@ 14 seconds ago');
QUERY: INSERT INTO RELTIME_TBL (f1) VALUES ('badly formatted reltime');
--
-- RELTIME
--
CREATE TABLE RELTIME_TBL (f1 reltime);
INSERT INTO RELTIME_TBL (f1) VALUES ('@ 1 minute');
INSERT INTO RELTIME_TBL (f1) VALUES ('@ 5 hour');
INSERT INTO RELTIME_TBL (f1) VALUES ('@ 10 day');
INSERT INTO RELTIME_TBL (f1) VALUES ('@ 34 year');
INSERT INTO RELTIME_TBL (f1) VALUES ('@ 3 months');
INSERT INTO RELTIME_TBL (f1) VALUES ('@ 14 seconds ago');
-- badly formatted reltimes
INSERT INTO RELTIME_TBL (f1) VALUES ('badly formatted reltime');
ERROR: Bad reltime external representation 'badly formatted reltime'
QUERY: INSERT INTO RELTIME_TBL (f1) VALUES ('@ 30 eons ago');
INSERT INTO RELTIME_TBL (f1) VALUES ('@ 30 eons ago');
ERROR: Bad reltime external representation '@ 30 eons ago'
QUERY: SELECT '' AS six, RELTIME_TBL.*;
-- test reltime operators
SELECT '' AS six, RELTIME_TBL.*;
six | f1
---+-------------
-----+---------------
| @ 1 min
| @ 5 hours
| @ 10 days
@ -20,10 +25,10 @@ six|f1
| @ 14 secs ago
(6 rows)
QUERY: SELECT '' AS five, RELTIME_TBL.*
WHERE RELTIME_TBL.f1 <> '@ 10 days'::reltime;
SELECT '' AS five, RELTIME_TBL.*
WHERE RELTIME_TBL.f1 <> reltime '@ 10 days';
five | f1
----+-------------
------+---------------
| @ 1 min
| @ 5 hours
| @ 34 years
@ -31,43 +36,43 @@ five|f1
| @ 14 secs ago
(5 rows)
QUERY: SELECT '' AS three, RELTIME_TBL.*
WHERE RELTIME_TBL.f1 <= '@ 5 hours'::reltime;
SELECT '' AS three, RELTIME_TBL.*
WHERE RELTIME_TBL.f1 <= reltime '@ 5 hours';
three | f1
-----+-------------
-------+---------------
| @ 1 min
| @ 5 hours
| @ 14 secs ago
(3 rows)
QUERY: SELECT '' AS three, RELTIME_TBL.*
WHERE RELTIME_TBL.f1 < '@ 1 day'::reltime;
SELECT '' AS three, RELTIME_TBL.*
WHERE RELTIME_TBL.f1 < reltime '@ 1 day';
three | f1
-----+-------------
-------+---------------
| @ 1 min
| @ 5 hours
| @ 14 secs ago
(3 rows)
QUERY: SELECT '' AS one, RELTIME_TBL.*
WHERE RELTIME_TBL.f1 = '@ 34 years'::reltime;
SELECT '' AS one, RELTIME_TBL.*
WHERE RELTIME_TBL.f1 = reltime '@ 34 years';
one | f1
---+----------
-----+------------
| @ 34 years
(1 row)
QUERY: SELECT '' AS two, RELTIME_TBL.*
WHERE RELTIME_TBL.f1 >= '@ 1 month'::reltime;
SELECT '' AS two, RELTIME_TBL.*
WHERE RELTIME_TBL.f1 >= reltime '@ 1 month';
two | f1
---+----------
-----+------------
| @ 34 years
| @ 3 mons
(2 rows)
QUERY: SELECT '' AS five, RELTIME_TBL.*
WHERE RELTIME_TBL.f1 > '@ 3 seconds ago'::reltime;
SELECT '' AS five, RELTIME_TBL.*
WHERE RELTIME_TBL.f1 > reltime '@ 3 seconds ago';
five | f1
----+----------
------+------------
| @ 1 min
| @ 5 hours
| @ 10 days
@ -75,12 +80,12 @@ five|f1
| @ 3 mons
(5 rows)
QUERY: SELECT '' AS fifteen, r1.*, r2.*
SELECT '' AS fifteen, r1.*, r2.*
FROM RELTIME_TBL r1, RELTIME_TBL r2
WHERE r1.f1 > r2.f1
ORDER BY r1.f1, r2.f1;
fifteen | f1 | f1
-------+----------+-------------
---------+------------+---------------
| @ 1 min | @ 14 secs ago
| @ 5 hours | @ 14 secs ago
| @ 5 hours | @ 1 min

117
src/test/regress/expected/strings.out
View File

@ -1,154 +1,169 @@
QUERY: SELECT 'first line'
--
-- STRINGS
-- Test various data entry syntaxes.
--
-- SQL92 string continuation syntax
SELECT 'first line'
' - next line'
' - third line'
AS "Three lines to one";
Three lines to one
-----------------------------------
-------------------------------------
first line - next line - third line
(1 row)
QUERY: SELECT 'first line'
-- illegal string continuation syntax
SELECT 'first line'
' - next line' /* this comment is not allowed here */
' - third line'
AS "Illegal comment within continuation";
ERROR: parser: parse error at or near "'"
QUERY: SELECT CAST(f1 AS text) AS "text(char)" FROM CHAR_TBL;
--
-- test conversions between various string types
--
SELECT CAST(f1 AS text) AS "text(char)" FROM CHAR_TBL;
text(char)
----------
------------
a
ab
abcd
abcd
(4 rows)
QUERY: SELECT CAST(f1 AS text) AS "text(varchar)" FROM VARCHAR_TBL;
SELECT CAST(f1 AS text) AS "text(varchar)" FROM VARCHAR_TBL;
text(varchar)
-------------
---------------
a
ab
abcd
abcd
(4 rows)
QUERY: SELECT CAST(name 'namefield' AS text) AS "text(name)";
SELECT CAST(name 'namefield' AS text) AS "text(name)";
text(name)
----------
------------
namefield
(1 row)
QUERY: SELECT CAST(f1 AS char) AS "char(text)" FROM TEXT_TBL;
SELECT CAST(f1 AS char) AS "char(text)" FROM TEXT_TBL;
char(text)
-----------------
-------------------
doh!
hi de ho neighbor
(2 rows)
QUERY: SELECT CAST(f1 AS char) AS "char(varchar)" FROM VARCHAR_TBL;
SELECT CAST(f1 AS char) AS "char(varchar)" FROM VARCHAR_TBL;
char(varchar)
-------------
---------------
a
ab
abcd
abcd
(4 rows)
QUERY: SELECT CAST(name 'namefield' AS char) AS "char(name)";
SELECT CAST(name 'namefield' AS char) AS "char(name)";
char(name)
----------
------------
namefield
(1 row)
QUERY: SELECT CAST(f1 AS varchar) AS "varchar(text)" FROM TEXT_TBL;
SELECT CAST(f1 AS varchar) AS "varchar(text)" FROM TEXT_TBL;
varchar(text)
-----------------
-------------------
doh!
hi de ho neighbor
(2 rows)
QUERY: SELECT CAST(f1 AS varchar) AS "varchar(char)" FROM CHAR_TBL;
SELECT CAST(f1 AS varchar) AS "varchar(char)" FROM CHAR_TBL;
varchar(char)
-------------
---------------
a
ab
abcd
abcd
(4 rows)
QUERY: SELECT CAST(name 'namefield' AS varchar) AS "varchar(name)";
SELECT CAST(name 'namefield' AS varchar) AS "varchar(name)";
varchar(name)
-------------
---------------
namefield
(1 row)
QUERY: SELECT TRIM(BOTH FROM ' bunch o blanks ') AS "bunch o blanks";
bunch o blanks
--------------
bunch o blanks
(1 row)
QUERY: SELECT TRIM(LEADING FROM ' bunch o blanks ') AS "bunch o blanks ";
--
-- test SQL92 string functions
--
SELECT TRIM(BOTH FROM ' bunch o blanks ') AS "bunch o blanks";
bunch o blanks
----------------
bunch o blanks
(1 row)
QUERY: SELECT TRIM(TRAILING FROM ' bunch o blanks ') AS " bunch o blanks";
SELECT TRIM(LEADING FROM ' bunch o blanks ') AS "bunch o blanks ";
bunch o blanks
----------------
------------------
bunch o blanks
(1 row)
QUERY: SELECT TRIM(BOTH 'x' FROM 'xxxxxsome Xsxxxxx') AS "some Xs";
SELECT TRIM(TRAILING FROM ' bunch o blanks ') AS " bunch o blanks";
bunch o blanks
------------------
bunch o blanks
(1 row)
SELECT TRIM(BOTH 'x' FROM 'xxxxxsome Xsxxxxx') AS "some Xs";
some Xs
-------
---------
some Xs
(1 row)
QUERY: SELECT SUBSTRING('1234567890' FROM 3) AS "34567890";
SELECT SUBSTRING('1234567890' FROM 3) AS "34567890";
34567890
--------
----------
34567890
(1 row)
QUERY: SELECT SUBSTRING('1234567890' FROM 4 FOR 3) AS "456";
SELECT SUBSTRING('1234567890' FROM 4 FOR 3) AS "456";
456
-----
456
(1 row)
SELECT POSITION('4' IN '1234567890') AS "4";
4
---
456
(1 row)
QUERY: SELECT POSITION('4' IN '1234567890') AS "4";
4
-
4
(1 row)
QUERY: SELECT POSITION(5 IN '1234567890') AS "5";
SELECT POSITION(5 IN '1234567890') AS "5";
5
-
---
5
(1 row)
QUERY: SELECT 'unknown' || ' and unknown' AS "Concat unknown types";
--
-- test implicit type conversion
--
SELECT 'unknown' || ' and unknown' AS "Concat unknown types";
Concat unknown types
--------------------
----------------------
unknown and unknown
(1 row)
QUERY: SELECT text 'text' || ' and unknown' AS "Concat text to unknown type";
SELECT text 'text' || ' and unknown' AS "Concat text to unknown type";
Concat text to unknown type
---------------------------
-----------------------------
text and unknown
(1 row)
QUERY: SELECT text 'text' || char ' and char' AS "Concat text to char";
SELECT text 'text' || char ' and char' AS "Concat text to char";
Concat text to char
-------------------
---------------------
text and char
(1 row)
QUERY: SELECT text 'text' || varchar ' and varchar' AS "Concat text to varchar";
SELECT text 'text' || varchar ' and varchar' AS "Concat text to varchar";
Concat text to varchar
----------------------
------------------------
text and varchar
(1 row)

75
src/test/regress/expected/timespan.out
View File

@ -1,21 +1,26 @@
QUERY: CREATE TABLE TIMESPAN_TBL (f1 timespan);
QUERY: INSERT INTO TIMESPAN_TBL (f1) VALUES ('@ 1 minute');
QUERY: INSERT INTO TIMESPAN_TBL (f1) VALUES ('@ 5 hour');
QUERY: INSERT INTO TIMESPAN_TBL (f1) VALUES ('@ 10 day');
QUERY: INSERT INTO TIMESPAN_TBL (f1) VALUES ('@ 34 year');
QUERY: INSERT INTO TIMESPAN_TBL (f1) VALUES ('@ 3 months');
QUERY: INSERT INTO TIMESPAN_TBL (f1) VALUES ('@ 14 seconds ago');
QUERY: INSERT INTO TIMESPAN_TBL (f1) VALUES ('1 day 2 hours 3 minutes 4 seconds');
QUERY: INSERT INTO TIMESPAN_TBL (f1) VALUES ('6 years');
QUERY: INSERT INTO TIMESPAN_TBL (f1) VALUES ('5 months');
QUERY: INSERT INTO TIMESPAN_TBL (f1) VALUES ('5 months 12 hours');
QUERY: INSERT INTO TIMESPAN_TBL (f1) VALUES ('badly formatted timespan');
--
-- TIMESPAN
--
CREATE TABLE TIMESPAN_TBL (f1 timespan);
INSERT INTO TIMESPAN_TBL (f1) VALUES ('@ 1 minute');
INSERT INTO TIMESPAN_TBL (f1) VALUES ('@ 5 hour');
INSERT INTO TIMESPAN_TBL (f1) VALUES ('@ 10 day');
INSERT INTO TIMESPAN_TBL (f1) VALUES ('@ 34 year');
INSERT INTO TIMESPAN_TBL (f1) VALUES ('@ 3 months');
INSERT INTO TIMESPAN_TBL (f1) VALUES ('@ 14 seconds ago');
INSERT INTO TIMESPAN_TBL (f1) VALUES ('1 day 2 hours 3 minutes 4 seconds');
INSERT INTO TIMESPAN_TBL (f1) VALUES ('6 years');
INSERT INTO TIMESPAN_TBL (f1) VALUES ('5 months');
INSERT INTO TIMESPAN_TBL (f1) VALUES ('5 months 12 hours');
-- badly formatted timespan
INSERT INTO TIMESPAN_TBL (f1) VALUES ('badly formatted timespan');
ERROR: Bad timespan external representation 'badly formatted timespan'
QUERY: INSERT INTO TIMESPAN_TBL (f1) VALUES ('@ 30 eons ago');
INSERT INTO TIMESPAN_TBL (f1) VALUES ('@ 30 eons ago');
ERROR: Bad timespan external representation '@ 30 eons ago'
QUERY: SELECT '' AS ten, TIMESPAN_TBL.*;
-- test timespan operators
SELECT '' AS ten, TIMESPAN_TBL.*;
ten | f1
---+-----------------------------
-----+-------------------------------
| @ 1 min
| @ 5 hours
| @ 10 days
@ -28,10 +33,10 @@ ten|f1
| @ 5 mons 12 hours
(10 rows)
QUERY: SELECT '' AS nine, TIMESPAN_TBL.*
WHERE TIMESPAN_TBL.f1 <> '@ 10 days'::timespan;
SELECT '' AS nine, TIMESPAN_TBL.*
WHERE TIMESPAN_TBL.f1 <> timespan '@ 10 days';
nine | f1
----+-----------------------------
------+-------------------------------
| @ 1 min
| @ 5 hours
| @ 34 years
@ -43,35 +48,35 @@ nine|f1
| @ 5 mons 12 hours
(9 rows)
QUERY: SELECT '' AS three, TIMESPAN_TBL.*
WHERE TIMESPAN_TBL.f1 <= '@ 5 hours'::timespan;
SELECT '' AS three, TIMESPAN_TBL.*
WHERE TIMESPAN_TBL.f1 <= timespan '@ 5 hours';
three | f1
-----+-------------
-------+---------------
| @ 1 min
| @ 5 hours
| @ 14 secs ago
(3 rows)
QUERY: SELECT '' AS three, TIMESPAN_TBL.*
WHERE TIMESPAN_TBL.f1 < '@ 1 day'::timespan;
SELECT '' AS three, TIMESPAN_TBL.*
WHERE TIMESPAN_TBL.f1 < timespan '@ 1 day';
three | f1
-----+-------------
-------+---------------
| @ 1 min
| @ 5 hours
| @ 14 secs ago
(3 rows)
QUERY: SELECT '' AS one, TIMESPAN_TBL.*
WHERE TIMESPAN_TBL.f1 = '@ 34 years'::timespan;
SELECT '' AS one, TIMESPAN_TBL.*
WHERE TIMESPAN_TBL.f1 = timespan '@ 34 years';
one | f1
---+----------
-----+------------
| @ 34 years
(1 row)
QUERY: SELECT '' AS five, TIMESPAN_TBL.*
WHERE TIMESPAN_TBL.f1 >= '@ 1 month'::timespan;
SELECT '' AS five, TIMESPAN_TBL.*
WHERE TIMESPAN_TBL.f1 >= timespan '@ 1 month';
five | f1
----+-----------------
------+-------------------
| @ 34 years
| @ 3 mons
| @ 6 years
@ -79,10 +84,10 @@ five|f1
| @ 5 mons 12 hours
(5 rows)
QUERY: SELECT '' AS nine, TIMESPAN_TBL.*
WHERE TIMESPAN_TBL.f1 > '@ 3 seconds ago'::timespan;
SELECT '' AS nine, TIMESPAN_TBL.*
WHERE TIMESPAN_TBL.f1 > timespan '@ 3 seconds ago';
nine | f1
----+-----------------------------
------+-------------------------------
| @ 1 min
| @ 5 hours
| @ 10 days
@ -94,12 +99,12 @@ nine|f1
| @ 5 mons 12 hours
(9 rows)
QUERY: SELECT '' AS fortyfive, r1.*, r2.*
SELECT '' AS fortyfive, r1.*, r2.*
FROM TIMESPAN_TBL r1, TIMESPAN_TBL r2
WHERE r1.f1 > r2.f1
ORDER BY r1.f1, r2.f1;
fortyfive | f1 | f1
---------+-----------------------------+-----------------------------
-----------+-------------------------------+-------------------------------
| @ 1 min | @ 14 secs ago
| @ 5 hours | @ 14 secs ago
| @ 5 hours | @ 1 min

90
src/test/regress/expected/tinterval.out
View File

@ -1,23 +1,28 @@
QUERY: CREATE TABLE TINTERVAL_TBL (f1 tinterval);
QUERY: INSERT INTO TINTERVAL_TBL (f1)
--
-- TINTERVAL
--
CREATE TABLE TINTERVAL_TBL (f1 tinterval);
INSERT INTO TINTERVAL_TBL (f1)
VALUES ('["-infinity" "infinity"]');
QUERY: INSERT INTO TINTERVAL_TBL (f1)
INSERT INTO TINTERVAL_TBL (f1)
VALUES ('["May 10, 1947 23:59:12" "Jan 14, 1973 03:14:21"]');
QUERY: INSERT INTO TINTERVAL_TBL (f1)
INSERT INTO TINTERVAL_TBL (f1)
VALUES ('["Sep 4, 1983 23:59:12" "Oct 4, 1983 23:59:12"]');
QUERY: INSERT INTO TINTERVAL_TBL (f1)
INSERT INTO TINTERVAL_TBL (f1)
VALUES ('["epoch" "Mon May 1 00:30:30 1995"]');
QUERY: INSERT INTO TINTERVAL_TBL (f1)
INSERT INTO TINTERVAL_TBL (f1)
VALUES ('["Feb 15 1990 12:15:03" "current"]');
QUERY: INSERT INTO TINTERVAL_TBL (f1)
-- badly formatted tintervals
INSERT INTO TINTERVAL_TBL (f1)
VALUES ('["bad time specifications" ""]');
ERROR: Bad abstime external representation 'bad time specifications'
QUERY: INSERT INTO TINTERVAL_TBL (f1)
INSERT INTO TINTERVAL_TBL (f1)
VALUES ('["" "infinity"]');
ERROR: Bad abstime external representation ''
QUERY: SELECT '' AS five, TINTERVAL_TBL.*;
-- test tinterval operators
SELECT '' AS five, TINTERVAL_TBL.*;
five | f1
----+---------------------------------------------------------------
------+-----------------------------------------------------------------
| ["-infinity" "infinity"]
| ["Sat May 10 23:59:12 1947 PST" "Sun Jan 14 03:14:21 1973 PST"]
| ["Sun Sep 04 23:59:12 1983 PDT" "Tue Oct 04 23:59:12 1983 PDT"]
@ -25,78 +30,85 @@ five|f1
| ["Thu Feb 15 12:15:03 1990 PST" "current"]
(5 rows)
QUERY: SELECT '' AS one, t.*
-- length ==
SELECT '' AS one, t.*
FROM TINTERVAL_TBL t
WHERE t.f1 #= '@ 1 months';
one | f1
---+---------------------------------------------------------------
-----+-----------------------------------------------------------------
| ["Sun Sep 04 23:59:12 1983 PDT" "Tue Oct 04 23:59:12 1983 PDT"]
(1 row)
QUERY: SELECT '' AS three, t.*
-- length <>
SELECT '' AS three, t.*
FROM TINTERVAL_TBL t
WHERE t.f1 #<> '@ 1 months';
three | f1
-----+---------------------------------------------------------------
-------+-----------------------------------------------------------------
| ["Sat May 10 23:59:12 1947 PST" "Sun Jan 14 03:14:21 1973 PST"]
| ["epoch" "Mon May 01 00:30:30 1995 PDT"]
| ["Thu Feb 15 12:15:03 1990 PST" "current"]
(3 rows)
QUERY: SELECT '' AS zero, t.*
-- length <
SELECT '' AS zero, t.*
FROM TINTERVAL_TBL t
WHERE t.f1 #< '@ 1 month';
zero | f1
----+--
------+----
(0 rows)
QUERY: SELECT '' AS one, t.*
-- length <=
SELECT '' AS one, t.*
FROM TINTERVAL_TBL t
WHERE t.f1 #<= '@ 1 month';
one | f1
---+---------------------------------------------------------------
-----+-----------------------------------------------------------------
| ["Sun Sep 04 23:59:12 1983 PDT" "Tue Oct 04 23:59:12 1983 PDT"]
(1 row)
QUERY: SELECT '' AS three, t.*
-- length >
SELECT '' AS three, t.*
FROM TINTERVAL_TBL t
WHERE t.f1 #> '@ 1 year';
three | f1
-----+---------------------------------------------------------------
-------+-----------------------------------------------------------------
| ["Sat May 10 23:59:12 1947 PST" "Sun Jan 14 03:14:21 1973 PST"]
| ["epoch" "Mon May 01 00:30:30 1995 PDT"]
| ["Thu Feb 15 12:15:03 1990 PST" "current"]
(3 rows)
QUERY: SELECT '' AS three, t.*
-- length >=
SELECT '' AS three, t.*
FROM TINTERVAL_TBL t
WHERE t.f1 #>= '@ 3 years';
three | f1
-----+---------------------------------------------------------------
-------+-----------------------------------------------------------------
| ["Sat May 10 23:59:12 1947 PST" "Sun Jan 14 03:14:21 1973 PST"]
| ["epoch" "Mon May 01 00:30:30 1995 PDT"]
| ["Thu Feb 15 12:15:03 1990 PST" "current"]
(3 rows)
QUERY: SELECT '' AS three, t1.*
-- overlaps
SELECT '' AS three, t1.*
FROM TINTERVAL_TBL t1
WHERE t1.f1 &&
'["Aug 15 14:23:19 1983" "Sep 16 14:23:19 1983"]'::tinterval;
tinterval '["Aug 15 14:23:19 1983" "Sep 16 14:23:19 1983"]';
three | f1
-----+---------------------------------------------------------------
-------+-----------------------------------------------------------------
| ["-infinity" "infinity"]
| ["Sun Sep 04 23:59:12 1983 PDT" "Tue Oct 04 23:59:12 1983 PDT"]
| ["epoch" "Mon May 01 00:30:30 1995 PDT"]
(3 rows)
QUERY: SET geqo TO 'off';
QUERY: SELECT '' AS five, t1.f1, t2.f1
SET geqo TO 'off';
SELECT '' AS five, t1.f1, t2.f1
FROM TINTERVAL_TBL t1, TINTERVAL_TBL t2
WHERE t1.f1 && t2.f1 and
t1.f1 = t2.f1
ORDER BY t1.f1, t2.f1;
five | f1 | f1
----+---------------------------------------------------------------+---------------------------------------------------------------
------+-----------------------------------------------------------------+-----------------------------------------------------------------
| ["-infinity" "infinity"] | ["-infinity" "infinity"]
| ["Sun Sep 04 23:59:12 1983 PDT" "Tue Oct 04 23:59:12 1983 PDT"] | ["Sun Sep 04 23:59:12 1983 PDT" "Tue Oct 04 23:59:12 1983 PDT"]
| ["Thu Feb 15 12:15:03 1990 PST" "current"] | ["Thu Feb 15 12:15:03 1990 PST" "current"]
@ -104,12 +116,12 @@ five|f1 |f1
| ["Sat May 10 23:59:12 1947 PST" "Sun Jan 14 03:14:21 1973 PST"] | ["Sat May 10 23:59:12 1947 PST" "Sun Jan 14 03:14:21 1973 PST"]
(5 rows)
QUERY: SELECT '' AS fourteen, t1.f1 AS interval1, t2.f1 AS interval2
SELECT '' AS fourteen, t1.f1 AS interval1, t2.f1 AS interval2
FROM TINTERVAL_TBL t1, TINTERVAL_TBL t2
WHERE t1.f1 && t2.f1 and not t1.f1 = t2.f1
ORDER BY interval1, interval2;
fourteen | interval1 | interval2
--------+---------------------------------------------------------------+---------------------------------------------------------------
----------+-----------------------------------------------------------------+-----------------------------------------------------------------
| ["-infinity" "infinity"] | ["Sun Sep 04 23:59:12 1983 PDT" "Tue Oct 04 23:59:12 1983 PDT"]
| ["-infinity" "infinity"] | ["Thu Feb 15 12:15:03 1990 PST" "current"]
| ["-infinity" "infinity"] | ["epoch" "Mon May 01 00:30:30 1995 PDT"]
@ -126,29 +138,31 @@ fourteen|interval1 |interva
| ["Sat May 10 23:59:12 1947 PST" "Sun Jan 14 03:14:21 1973 PST"] | ["epoch" "Mon May 01 00:30:30 1995 PDT"]
(14 rows)
QUERY: SELECT '' AS five, t1.f1
-- contains
SELECT '' AS five, t1.f1
FROM TINTERVAL_TBL t1
WHERE not t1.f1 <<
'["Aug 15 14:23:19 1980" "Sep 16 14:23:19 1990"]'::tinterval
tinterval '["Aug 15 14:23:19 1980" "Sep 16 14:23:19 1990"]'
ORDER BY t1.f1;
five | f1
----+---------------------------------------------------------------
------+-----------------------------------------------------------------
| ["Sun Sep 04 23:59:12 1983 PDT" "Tue Oct 04 23:59:12 1983 PDT"]
| ["Thu Feb 15 12:15:03 1990 PST" "current"]
| ["Sat May 10 23:59:12 1947 PST" "Sun Jan 14 03:14:21 1973 PST"]
(3 rows)
QUERY: SELECT '' AS three, t1.f1
-- make time interval
SELECT '' AS three, t1.f1
FROM TINTERVAL_TBL t1
WHERE t1.f1 &&
('Aug 15 14:23:19 1983'::abstime <#>
'Sep 16 14:23:19 1983'::abstime)
(abstime 'Aug 15 14:23:19 1983' <#>
abstime 'Sep 16 14:23:19 1983')
ORDER BY t1.f1;
three | f1
-----+---------------------------------------------------------------
-------+-----------------------------------------------------------------
| ["-infinity" "infinity"]
| ["Sun Sep 04 23:59:12 1983 PDT" "Tue Oct 04 23:59:12 1983 PDT"]
| ["epoch" "Mon May 01 00:30:30 1995 PDT"]
(3 rows)
QUERY: RESET geqo;
RESET geqo;

106
src/test/regress/expected/type_sanity.out
View File

@ -1,4 +1,19 @@
QUERY: SELECT p1.oid, p1.typname
--
-- TYPE_SANITY
-- Sanity checks for common errors in making type-related system tables:
-- pg_type, pg_class, pg_attribute.
--
-- None of the SELECTs here should ever find any matching entries,
-- so the expected output is easy to maintain ;-).
-- A test failure indicates someone messed up an entry in the system tables.
--
-- NB: we assume the oidjoins test will have caught any dangling links,
-- that is OID or REGPROC fields that are not zero and do not match some
-- row in the linked-to table. However, if we want to enforce that a link
-- field can't be 0, we have to check it here.
-- **************** pg_type ****************
-- Look for illegal values in pg_type fields.
SELECT p1.oid, p1.typname
FROM pg_type as p1
WHERE (p1.typlen <= 0 AND p1.typlen != -1) OR
(p1.typtype != 'b' AND p1.typtype != 'c') OR
@ -6,127 +21,158 @@ WHERE (p1.typlen <= 0 AND p1.typlen != -1) OR
(p1.typalign != 'c' AND p1.typalign != 's' AND
p1.typalign != 'i' AND p1.typalign != 'd');
oid | typname
---+-------
-----+---------
(0 rows)
QUERY: SELECT p1.oid, p1.typname
-- Look for "pass by value" types that can't be passed by value.
SELECT p1.oid, p1.typname
FROM pg_type as p1
WHERE p1.typbyval AND
(p1.typlen != 1 OR p1.typalign != 'c') AND
(p1.typlen != 2 OR p1.typalign != 's') AND
(p1.typlen != 4 OR p1.typalign != 'i');
oid | typname
---+-------
-----+---------
(0 rows)
QUERY: SELECT p1.oid, p1.typname
-- Look for complex types that do not have a typrelid entry,
-- or basic types that do.
SELECT p1.oid, p1.typname
FROM pg_type as p1
WHERE (p1.typtype = 'c' AND p1.typrelid = 0) OR
(p1.typtype != 'c' AND p1.typrelid != 0);
oid | typname
---+-------
-----+---------
(0 rows)
QUERY: SELECT p1.oid, p1.typname
-- Conversion routines must be provided except in 'c' entries.
SELECT p1.oid, p1.typname
FROM pg_type as p1
WHERE p1.typtype != 'c' AND
(p1.typinput = 0 OR p1.typoutput = 0 OR
p1.typreceive = 0 OR p1.typsend = 0);
oid | typname
---+-------
-----+---------
(0 rows)
QUERY: SELECT p1.oid, p1.typname, p2.oid, p2.proname
-- Check for bogus typinput routines
-- FIXME: ought to check prorettype, but there are special cases that make it
-- hard: prorettype might be binary-compatible with the type but not the same,
-- and for array types array_in's result has nothing to do with anything.
SELECT p1.oid, p1.typname, p2.oid, p2.proname
FROM pg_type AS p1, pg_proc AS p2
WHERE p1.typinput = p2.oid AND p1.typtype = 'b' AND
(p2.pronargs != 1 OR p2.proretset) AND
(p2.pronargs != 3 OR p2.proretset OR p2.proargtypes[2] != 23);
oid | typname | oid | proname
---+-------+---+-------
-----+---------+-----+---------
(0 rows)
QUERY: SELECT p1.oid, p1.typname, p2.oid, p2.proname
-- Check for bogus typoutput routines
-- The first OR subclause detects bogus non-array cases,
-- the second one detects bogus array cases.
-- FIXME: ought to check prorettype, but not clear what it should be.
SELECT p1.oid, p1.typname, p2.oid, p2.proname
FROM pg_type AS p1, pg_proc AS p2
WHERE p1.typoutput = p2.oid AND p1.typtype = 'b' AND
(p2.pronargs != 1 OR p2.proretset) AND
(p2.pronargs != 2 OR p2.proretset OR p1.typelem = 0);
oid | typname | oid | proname
---+-------+---+-------
-----+---------+-----+---------
(0 rows)
QUERY: SELECT p1.oid, p1.typname, p2.oid, p2.proname
-- Check for bogus typreceive routines
-- FIXME: ought to check prorettype, but there are special cases that make it
-- hard: prorettype might be binary-compatible with the type but not the same,
-- and for array types array_in's result has nothing to do with anything.
SELECT p1.oid, p1.typname, p2.oid, p2.proname
FROM pg_type AS p1, pg_proc AS p2
WHERE p1.typreceive = p2.oid AND p1.typtype = 'b' AND
(p2.pronargs != 1 OR p2.proretset) AND
(p2.pronargs != 3 OR p2.proretset OR p2.proargtypes[2] != 23);
oid | typname | oid | proname
---+-------+---+-------
-----+---------+-----+---------
(0 rows)
QUERY: SELECT p1.oid, p1.typname, p2.oid, p2.proname
-- Check for bogus typsend routines
-- The first OR subclause detects bogus non-array cases,
-- the second one detects bogus array cases.
-- FIXME: ought to check prorettype, but not clear what it should be.
SELECT p1.oid, p1.typname, p2.oid, p2.proname
FROM pg_type AS p1, pg_proc AS p2
WHERE p1.typsend = p2.oid AND p1.typtype = 'b' AND
(p2.pronargs != 1 OR p2.proretset) AND
(p2.pronargs != 2 OR p2.proretset OR p1.typelem = 0);
oid | typname | oid | proname
---+-------+---+-------
-----+---------+-----+---------
(0 rows)
QUERY: SELECT p1.oid, p1.relname
-- **************** pg_class ****************
-- Look for illegal values in pg_class fields
SELECT p1.oid, p1.relname
FROM pg_class as p1
WHERE (p1.relkind != 'r' AND p1.relkind != 'i' AND
p1.relkind != 's' AND p1.relkind != 'S');
oid | relname
---+-------
-----+---------
(0 rows)
QUERY: SELECT p1.oid, p1.relname
-- Indexes should have an access method, others not.
SELECT p1.oid, p1.relname
FROM pg_class as p1
WHERE (p1.relkind = 'i' AND p1.relam = 0) OR
(p1.relkind != 'i' AND p1.relam != 0);
oid | relname
---+-------
-----+---------
(0 rows)
QUERY: SELECT p1.oid, p1.attrelid, p1.attname
-- **************** pg_attribute ****************
-- Look for illegal values in pg_attribute fields
SELECT p1.oid, p1.attrelid, p1.attname
FROM pg_attribute as p1
WHERE p1.attrelid = 0 OR p1.atttypid = 0 OR p1.attnum = 0 OR
p1.attcacheoff != -1;
oid | attrelid | attname
---+--------+-------
-----+----------+---------
(0 rows)
QUERY: SELECT p1.oid, p1.attname, p2.oid, p2.attname
-- Look for duplicate pg_attribute entries
-- (This would not be necessary if the indexes on pg_attribute were UNIQUE?)
SELECT p1.oid, p1.attname, p2.oid, p2.attname
FROM pg_attribute AS p1, pg_attribute AS p2
WHERE p1.oid != p2.oid AND
p1.attrelid = p2.attrelid AND
(p1.attname = p2.attname OR p1.attnum = p2.attnum);
oid | attname | oid | attname
---+-------+---+-------
-----+---------+-----+---------
(0 rows)
QUERY: SELECT p1.oid, p1.attname, p2.oid, p2.relname
-- Cross-check attnum against parent relation
SELECT p1.oid, p1.attname, p2.oid, p2.relname
FROM pg_attribute AS p1, pg_class AS p2
WHERE p1.attrelid = p2.oid AND p1.attnum > p2.relnatts;
oid | attname | oid | relname
---+-------+---+-------
-----+---------+-----+---------
(0 rows)
QUERY: SELECT p1.oid, p1.relname
-- Detect missing pg_attribute entries: should have as many non-system
-- attributes as parent relation expects
SELECT p1.oid, p1.relname
FROM pg_class AS p1
WHERE p1.relnatts != (SELECT count(*) FROM pg_attribute AS p2
WHERE p2.attrelid = p1.oid AND p2.attnum > 0);
oid | relname
---+-------
-----+---------
(0 rows)
QUERY: SELECT p1.oid, p1.attname, p2.oid, p2.typname
-- Cross-check against pg_type entry
SELECT p1.oid, p1.attname, p2.oid, p2.typname
FROM pg_attribute AS p1, pg_type AS p2
WHERE p1.atttypid = p2.oid AND
(p1.attlen != p2.typlen OR
p1.attalign != p2.typalign OR
p1.attbyval != p2.typbyval);
oid | attname | oid | typname
---+-------+---+-------
-----+---------+-----+---------
(0 rows)