2000-09-12 07:42:20 +02:00
|
|
|
--
|
|
|
|
-- TIME
|
|
|
|
--
|
2001-10-03 07:29:27 +02:00
|
|
|
CREATE TABLE TIME_TBL (f1 time(2));
|
2001-09-28 10:00:11 +02:00
|
|
|
INSERT INTO TIME_TBL VALUES ('00:00');
|
|
|
|
INSERT INTO TIME_TBL VALUES ('01:00');
|
2003-01-31 02:08:08 +01:00
|
|
|
-- as of 7.4, timezone spec should be accepted and ignored
|
|
|
|
INSERT INTO TIME_TBL VALUES ('02:03 PST');
|
|
|
|
INSERT INTO TIME_TBL VALUES ('11:59 EDT');
|
2001-09-28 10:00:11 +02:00
|
|
|
INSERT INTO TIME_TBL VALUES ('12:00');
|
|
|
|
INSERT INTO TIME_TBL VALUES ('12:01');
|
|
|
|
INSERT INTO TIME_TBL VALUES ('23:59');
|
|
|
|
INSERT INTO TIME_TBL VALUES ('11:59:59.99 PM');
|
2006-07-06 03:46:38 +02:00
|
|
|
INSERT INTO TIME_TBL VALUES ('2003-03-07 15:36:39 America/New_York');
|
|
|
|
INSERT INTO TIME_TBL VALUES ('2003-07-07 15:36:39 America/New_York');
|
|
|
|
-- this should fail (the timezone offset is not known)
|
|
|
|
INSERT INTO TIME_TBL VALUES ('15:36:39 America/New_York');
|
|
|
|
ERROR: invalid input syntax for type time: "15:36:39 America/New_York"
|
2008-09-01 22:42:46 +02:00
|
|
|
LINE 1: INSERT INTO TIME_TBL VALUES ('15:36:39 America/New_York');
|
|
|
|
^
|
2001-09-28 10:00:11 +02:00
|
|
|
SELECT f1 AS "Time" FROM TIME_TBL;
|
2001-10-03 07:29:27 +02:00
|
|
|
Time
|
|
|
|
-------------
|
2001-09-28 10:00:11 +02:00
|
|
|
00:00:00
|
|
|
|
01:00:00
|
|
|
|
02:03:00
|
|
|
|
11:59:00
|
|
|
|
12:00:00
|
|
|
|
12:01:00
|
|
|
|
23:59:00
|
2001-10-03 07:29:27 +02:00
|
|
|
23:59:59.99
|
2006-07-06 03:46:38 +02:00
|
|
|
15:36:39
|
|
|
|
15:36:39
|
|
|
|
(10 rows)
|
2000-09-12 07:42:20 +02:00
|
|
|
|
|
|
|
SELECT f1 AS "Three" FROM TIME_TBL WHERE f1 < '05:06:07';
|
|
|
|
Three
|
|
|
|
----------
|
|
|
|
00:00:00
|
|
|
|
01:00:00
|
|
|
|
02:03:00
|
|
|
|
(3 rows)
|
|
|
|
|
|
|
|
SELECT f1 AS "Five" FROM TIME_TBL WHERE f1 > '05:06:07';
|
2001-10-03 07:29:27 +02:00
|
|
|
Five
|
|
|
|
-------------
|
2000-09-12 07:42:20 +02:00
|
|
|
11:59:00
|
|
|
|
12:00:00
|
|
|
|
12:01:00
|
|
|
|
23:59:00
|
2001-10-03 07:29:27 +02:00
|
|
|
23:59:59.99
|
2006-07-06 03:46:38 +02:00
|
|
|
15:36:39
|
|
|
|
15:36:39
|
|
|
|
(7 rows)
|
2000-09-12 07:42:20 +02:00
|
|
|
|
|
|
|
SELECT f1 AS "None" FROM TIME_TBL WHERE f1 < '00:00';
|
|
|
|
None
|
|
|
|
------
|
|
|
|
(0 rows)
|
|
|
|
|
|
|
|
SELECT f1 AS "Eight" FROM TIME_TBL WHERE f1 >= '00:00';
|
2001-10-03 07:29:27 +02:00
|
|
|
Eight
|
|
|
|
-------------
|
2000-09-12 07:42:20 +02:00
|
|
|
00:00:00
|
|
|
|
01:00:00
|
|
|
|
02:03:00
|
|
|
|
11:59:00
|
|
|
|
12:00:00
|
|
|
|
12:01:00
|
|
|
|
23:59:00
|
2001-10-03 07:29:27 +02:00
|
|
|
23:59:59.99
|
2006-07-06 03:46:38 +02:00
|
|
|
15:36:39
|
|
|
|
15:36:39
|
|
|
|
(10 rows)
|
2000-09-12 07:42:20 +02:00
|
|
|
|
2020-06-04 22:42:08 +02:00
|
|
|
-- Check edge cases
|
|
|
|
SELECT '23:59:59.999999'::time;
|
|
|
|
time
|
|
|
|
-----------------
|
|
|
|
23:59:59.999999
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
SELECT '23:59:59.9999999'::time; -- rounds up
|
|
|
|
time
|
|
|
|
----------
|
|
|
|
24:00:00
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
SELECT '23:59:60'::time; -- rounds up
|
|
|
|
time
|
|
|
|
----------
|
|
|
|
24:00:00
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
SELECT '24:00:00'::time; -- allowed
|
|
|
|
time
|
|
|
|
----------
|
|
|
|
24:00:00
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
SELECT '24:00:00.01'::time; -- not allowed
|
|
|
|
ERROR: date/time field value out of range: "24:00:00.01"
|
|
|
|
LINE 1: SELECT '24:00:00.01'::time;
|
|
|
|
^
|
|
|
|
SELECT '23:59:60.01'::time; -- not allowed
|
|
|
|
ERROR: date/time field value out of range: "23:59:60.01"
|
|
|
|
LINE 1: SELECT '23:59:60.01'::time;
|
|
|
|
^
|
|
|
|
SELECT '24:01:00'::time; -- not allowed
|
|
|
|
ERROR: date/time field value out of range: "24:01:00"
|
|
|
|
LINE 1: SELECT '24:01:00'::time;
|
|
|
|
^
|
|
|
|
SELECT '25:00:00'::time; -- not allowed
|
|
|
|
ERROR: date/time field value out of range: "25:00:00"
|
|
|
|
LINE 1: SELECT '25:00:00'::time;
|
|
|
|
^
|
2000-09-12 07:42:20 +02:00
|
|
|
--
|
|
|
|
-- TIME simple math
|
|
|
|
--
|
2000-12-03 15:51:12 +01:00
|
|
|
-- We now make a distinction between time and intervals,
|
|
|
|
-- and adding two times together makes no sense at all.
|
|
|
|
-- Leave in one query to show that it is rejected,
|
|
|
|
-- and do the rest of the testing in horology.sql
|
|
|
|
-- where we do mixed-type arithmetic. - thomas 2000-12-02
|
|
|
|
SELECT f1 + time '00:01' AS "Illegal" FROM TIME_TBL;
|
2003-07-04 04:51:34 +02:00
|
|
|
ERROR: operator is not unique: time without time zone + time without time zone
|
2006-03-14 23:48:25 +01:00
|
|
|
LINE 1: SELECT f1 + time '00:01' AS "Illegal" FROM TIME_TBL;
|
|
|
|
^
|
Wording cleanup for error messages. Also change can't -> cannot.
Standard English uses "may", "can", and "might" in different ways:
may - permission, "You may borrow my rake."
can - ability, "I can lift that log."
might - possibility, "It might rain today."
Unfortunately, in conversational English, their use is often mixed, as
in, "You may use this variable to do X", when in fact, "can" is a better
choice. Similarly, "It may crash" is better stated, "It might crash".
2007-02-01 20:10:30 +01:00
|
|
|
HINT: Could not choose a best candidate operator. You might need to add explicit type casts.
|
2020-06-14 07:48:15 +02:00
|
|
|
--
|
|
|
|
-- test EXTRACT
|
|
|
|
--
|
|
|
|
SELECT EXTRACT(MICROSECOND FROM TIME '2020-05-26 13:30:25.575401');
|
Change return type of EXTRACT to numeric
The previous implementation of EXTRACT mapped internally to
date_part(), which returned type double precision (since it was
implemented long before the numeric type existed). This can lead to
imprecise output in some cases, so returning numeric would be
preferrable. Changing the return type of an existing function is a
bit risky, so instead we do the following: We implement a new set of
functions, which are now called "extract", in parallel to the existing
date_part functions. They work the same way internally but use
numeric instead of float8. The EXTRACT construct is now mapped by the
parser to these new extract functions. That way, dumps of views
etc. from old versions (which would use date_part) continue to work
unchanged, but new uses will map to the new extract functions.
Additionally, the reverse compilation of EXTRACT now reproduces the
original syntax, using the new mechanism introduced in
40c24bfef92530bd846e111c1742c2a54441c62c.
The following minor changes of behavior result from the new
implementation:
- The column name from an isolated EXTRACT call is now "extract"
instead of "date_part".
- Extract from date now rejects inappropriate field names such as
HOUR. It was previously mapped internally to extract from
timestamp, so it would silently accept everything appropriate for
timestamp.
- Return values when extracting fields with possibly fractional
values, such as second and epoch, now have the full scale that the
value has internally (so, for example, '1.000000' instead of just
'1').
Reported-by: Petr Fedorov <petr.fedorov@phystech.edu>
Reviewed-by: Tom Lane <tgl@sss.pgh.pa.us>
Discussion: https://www.postgresql.org/message-id/flat/42b73d2d-da12-ba9f-570a-420e0cce19d9@phystech.edu
2021-04-06 07:17:13 +02:00
|
|
|
extract
|
|
|
|
----------
|
|
|
|
25575401
|
2020-06-14 07:48:15 +02:00
|
|
|
(1 row)
|
|
|
|
|
|
|
|
SELECT EXTRACT(MILLISECOND FROM TIME '2020-05-26 13:30:25.575401');
|
Change return type of EXTRACT to numeric
The previous implementation of EXTRACT mapped internally to
date_part(), which returned type double precision (since it was
implemented long before the numeric type existed). This can lead to
imprecise output in some cases, so returning numeric would be
preferrable. Changing the return type of an existing function is a
bit risky, so instead we do the following: We implement a new set of
functions, which are now called "extract", in parallel to the existing
date_part functions. They work the same way internally but use
numeric instead of float8. The EXTRACT construct is now mapped by the
parser to these new extract functions. That way, dumps of views
etc. from old versions (which would use date_part) continue to work
unchanged, but new uses will map to the new extract functions.
Additionally, the reverse compilation of EXTRACT now reproduces the
original syntax, using the new mechanism introduced in
40c24bfef92530bd846e111c1742c2a54441c62c.
The following minor changes of behavior result from the new
implementation:
- The column name from an isolated EXTRACT call is now "extract"
instead of "date_part".
- Extract from date now rejects inappropriate field names such as
HOUR. It was previously mapped internally to extract from
timestamp, so it would silently accept everything appropriate for
timestamp.
- Return values when extracting fields with possibly fractional
values, such as second and epoch, now have the full scale that the
value has internally (so, for example, '1.000000' instead of just
'1').
Reported-by: Petr Fedorov <petr.fedorov@phystech.edu>
Reviewed-by: Tom Lane <tgl@sss.pgh.pa.us>
Discussion: https://www.postgresql.org/message-id/flat/42b73d2d-da12-ba9f-570a-420e0cce19d9@phystech.edu
2021-04-06 07:17:13 +02:00
|
|
|
extract
|
2020-06-14 07:48:15 +02:00
|
|
|
-----------
|
|
|
|
25575.401
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
SELECT EXTRACT(SECOND FROM TIME '2020-05-26 13:30:25.575401');
|
Change return type of EXTRACT to numeric
The previous implementation of EXTRACT mapped internally to
date_part(), which returned type double precision (since it was
implemented long before the numeric type existed). This can lead to
imprecise output in some cases, so returning numeric would be
preferrable. Changing the return type of an existing function is a
bit risky, so instead we do the following: We implement a new set of
functions, which are now called "extract", in parallel to the existing
date_part functions. They work the same way internally but use
numeric instead of float8. The EXTRACT construct is now mapped by the
parser to these new extract functions. That way, dumps of views
etc. from old versions (which would use date_part) continue to work
unchanged, but new uses will map to the new extract functions.
Additionally, the reverse compilation of EXTRACT now reproduces the
original syntax, using the new mechanism introduced in
40c24bfef92530bd846e111c1742c2a54441c62c.
The following minor changes of behavior result from the new
implementation:
- The column name from an isolated EXTRACT call is now "extract"
instead of "date_part".
- Extract from date now rejects inappropriate field names such as
HOUR. It was previously mapped internally to extract from
timestamp, so it would silently accept everything appropriate for
timestamp.
- Return values when extracting fields with possibly fractional
values, such as second and epoch, now have the full scale that the
value has internally (so, for example, '1.000000' instead of just
'1').
Reported-by: Petr Fedorov <petr.fedorov@phystech.edu>
Reviewed-by: Tom Lane <tgl@sss.pgh.pa.us>
Discussion: https://www.postgresql.org/message-id/flat/42b73d2d-da12-ba9f-570a-420e0cce19d9@phystech.edu
2021-04-06 07:17:13 +02:00
|
|
|
extract
|
2020-06-14 07:48:15 +02:00
|
|
|
-----------
|
|
|
|
25.575401
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
SELECT EXTRACT(MINUTE FROM TIME '2020-05-26 13:30:25.575401');
|
Change return type of EXTRACT to numeric
The previous implementation of EXTRACT mapped internally to
date_part(), which returned type double precision (since it was
implemented long before the numeric type existed). This can lead to
imprecise output in some cases, so returning numeric would be
preferrable. Changing the return type of an existing function is a
bit risky, so instead we do the following: We implement a new set of
functions, which are now called "extract", in parallel to the existing
date_part functions. They work the same way internally but use
numeric instead of float8. The EXTRACT construct is now mapped by the
parser to these new extract functions. That way, dumps of views
etc. from old versions (which would use date_part) continue to work
unchanged, but new uses will map to the new extract functions.
Additionally, the reverse compilation of EXTRACT now reproduces the
original syntax, using the new mechanism introduced in
40c24bfef92530bd846e111c1742c2a54441c62c.
The following minor changes of behavior result from the new
implementation:
- The column name from an isolated EXTRACT call is now "extract"
instead of "date_part".
- Extract from date now rejects inappropriate field names such as
HOUR. It was previously mapped internally to extract from
timestamp, so it would silently accept everything appropriate for
timestamp.
- Return values when extracting fields with possibly fractional
values, such as second and epoch, now have the full scale that the
value has internally (so, for example, '1.000000' instead of just
'1').
Reported-by: Petr Fedorov <petr.fedorov@phystech.edu>
Reviewed-by: Tom Lane <tgl@sss.pgh.pa.us>
Discussion: https://www.postgresql.org/message-id/flat/42b73d2d-da12-ba9f-570a-420e0cce19d9@phystech.edu
2021-04-06 07:17:13 +02:00
|
|
|
extract
|
|
|
|
---------
|
|
|
|
30
|
2020-06-14 07:48:15 +02:00
|
|
|
(1 row)
|
|
|
|
|
|
|
|
SELECT EXTRACT(HOUR FROM TIME '2020-05-26 13:30:25.575401');
|
Change return type of EXTRACT to numeric
The previous implementation of EXTRACT mapped internally to
date_part(), which returned type double precision (since it was
implemented long before the numeric type existed). This can lead to
imprecise output in some cases, so returning numeric would be
preferrable. Changing the return type of an existing function is a
bit risky, so instead we do the following: We implement a new set of
functions, which are now called "extract", in parallel to the existing
date_part functions. They work the same way internally but use
numeric instead of float8. The EXTRACT construct is now mapped by the
parser to these new extract functions. That way, dumps of views
etc. from old versions (which would use date_part) continue to work
unchanged, but new uses will map to the new extract functions.
Additionally, the reverse compilation of EXTRACT now reproduces the
original syntax, using the new mechanism introduced in
40c24bfef92530bd846e111c1742c2a54441c62c.
The following minor changes of behavior result from the new
implementation:
- The column name from an isolated EXTRACT call is now "extract"
instead of "date_part".
- Extract from date now rejects inappropriate field names such as
HOUR. It was previously mapped internally to extract from
timestamp, so it would silently accept everything appropriate for
timestamp.
- Return values when extracting fields with possibly fractional
values, such as second and epoch, now have the full scale that the
value has internally (so, for example, '1.000000' instead of just
'1').
Reported-by: Petr Fedorov <petr.fedorov@phystech.edu>
Reviewed-by: Tom Lane <tgl@sss.pgh.pa.us>
Discussion: https://www.postgresql.org/message-id/flat/42b73d2d-da12-ba9f-570a-420e0cce19d9@phystech.edu
2021-04-06 07:17:13 +02:00
|
|
|
extract
|
|
|
|
---------
|
|
|
|
13
|
2020-06-14 07:48:15 +02:00
|
|
|
(1 row)
|
|
|
|
|
|
|
|
SELECT EXTRACT(DAY FROM TIME '2020-05-26 13:30:25.575401'); -- error
|
|
|
|
ERROR: "time" units "day" not recognized
|
|
|
|
SELECT EXTRACT(FORTNIGHT FROM TIME '2020-05-26 13:30:25.575401'); -- error
|
|
|
|
ERROR: "time" units "fortnight" not recognized
|
|
|
|
SELECT EXTRACT(TIMEZONE FROM TIME '2020-05-26 13:30:25.575401'); -- error
|
|
|
|
ERROR: "time" units "timezone" not recognized
|
|
|
|
SELECT EXTRACT(EPOCH FROM TIME '2020-05-26 13:30:25.575401');
|
Change return type of EXTRACT to numeric
The previous implementation of EXTRACT mapped internally to
date_part(), which returned type double precision (since it was
implemented long before the numeric type existed). This can lead to
imprecise output in some cases, so returning numeric would be
preferrable. Changing the return type of an existing function is a
bit risky, so instead we do the following: We implement a new set of
functions, which are now called "extract", in parallel to the existing
date_part functions. They work the same way internally but use
numeric instead of float8. The EXTRACT construct is now mapped by the
parser to these new extract functions. That way, dumps of views
etc. from old versions (which would use date_part) continue to work
unchanged, but new uses will map to the new extract functions.
Additionally, the reverse compilation of EXTRACT now reproduces the
original syntax, using the new mechanism introduced in
40c24bfef92530bd846e111c1742c2a54441c62c.
The following minor changes of behavior result from the new
implementation:
- The column name from an isolated EXTRACT call is now "extract"
instead of "date_part".
- Extract from date now rejects inappropriate field names such as
HOUR. It was previously mapped internally to extract from
timestamp, so it would silently accept everything appropriate for
timestamp.
- Return values when extracting fields with possibly fractional
values, such as second and epoch, now have the full scale that the
value has internally (so, for example, '1.000000' instead of just
'1').
Reported-by: Petr Fedorov <petr.fedorov@phystech.edu>
Reviewed-by: Tom Lane <tgl@sss.pgh.pa.us>
Discussion: https://www.postgresql.org/message-id/flat/42b73d2d-da12-ba9f-570a-420e0cce19d9@phystech.edu
2021-04-06 07:17:13 +02:00
|
|
|
extract
|
|
|
|
--------------
|
|
|
|
48625.575401
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
-- date_part implementation is mostly the same as extract, so only
|
|
|
|
-- test a few cases for additional coverage.
|
|
|
|
SELECT date_part('microsecond', TIME '2020-05-26 13:30:25.575401');
|
|
|
|
date_part
|
|
|
|
-----------
|
|
|
|
25575401
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
SELECT date_part('millisecond', TIME '2020-05-26 13:30:25.575401');
|
|
|
|
date_part
|
|
|
|
-----------
|
|
|
|
25575.401
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
SELECT date_part('second', TIME '2020-05-26 13:30:25.575401');
|
|
|
|
date_part
|
|
|
|
-----------
|
|
|
|
25.575401
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
SELECT date_part('epoch', TIME '2020-05-26 13:30:25.575401');
|
2020-06-14 07:48:15 +02:00
|
|
|
date_part
|
|
|
|
--------------
|
|
|
|
48625.575401
|
|
|
|
(1 row)
|
|
|
|
|