Fix infinity and -infinity values for timestamp, timestamptz, and date.

Issue reported by Axel Rau.

Fixes #28

Author: James William Pye

postgresql/documentation/changes.txt

@@ -21,3 +21,5 @@ Changes
    protocol.element3.Tuple
  * Alter Statement.chunks() to return chunks of builtins.tuple. Being
    an interface intended for speed, types.Row() impedes its performance.
+ * Fix handling of infinity values with timestamptz, timestamp, and date.
+   Bug reported by Axel Rau.

postgresql/driver/pq3.py

@@ -2050,8 +2050,8 @@ def connect(self):
 		# manual binding
 		self.sys = pg_lib.Binding(self, pg_lib.sys)
 
-		if self.version_info <= (8,0):
-			meth = self.sys.startup_data_no_start
+		if self.version_info[:2] <= (8,0):
+			meth = self.sys.startup_data_only_version
 		else:
 			meth = self.sys.startup_data
 		# connection info

postgresql/lib/libsys.sql

@@ -130,6 +130,13 @@ SELECT
  client_port
 FROM pg_catalog.pg_stat_activity WHERE procpid = pg_catalog.pg_backend_pid();
 
+[startup_data_only_version:transient:first]
+SELECT
+ pg_catalog.version()::text,
+ NULL::text AS backend_start,
+ NULL::text AS client_addr,
+ NULL::text AS client_port;
+
 [sizeof_db:transient:first]
 SELECT pg_catalog.pg_database_size(current_database())::bigint
 

postgresql/python/datetime.py

@@ -1,12 +1,16 @@
 ##
-# copyright 2009, James William Pye
-# http://python.projects.postgresql.org
+# python.datetime - parts needed to use stdlib.datetime
 ##
-"""
-datetime extras
-"""
 import datetime
 
+##
+# stdlib.datetime representation of PostgreSQL 'infinity' and '-infinity'.
+infinity_datetime = datetime.datetime(datetime.MAXYEAR, 12, 31, 23, 59, 59, 999999)
+negative_infinity_datetime = datetime.datetime(datetime.MINYEAR, 1, 1, 0, 0, 0, 0)
+
+infinity_date = datetime.date(datetime.MAXYEAR, 12, 31)
+negative_infinity_date = datetime.date(datetime.MINYEAR, 1, 1)
+
 class FixedOffset(datetime.tzinfo):
 	def __init__(self, offset_in_seconds, tzname = None):
 		self._tzname = tzname

postgresql/test/test_driver.py

@@ -14,7 +14,9 @@
 from itertools import chain, islice
 from operator import itemgetter
 
-from ..python.datetime import FixedOffset
+from ..python.datetime import FixedOffset, \
+	negative_infinity_datetime, infinity_datetime, \
+	negative_infinity_date, infinity_date
 from .. import types as pg_types
 from ..types.io.stdlib_xml_etree import etree
 from .. import exceptions as pg_exc
@@ -172,6 +174,8 @@
 			datetime.datetime(2000,1,1,5,25,10),
 			datetime.datetime(500,1,1,5,25,10),
 			datetime.datetime(250,1,1,5,25,10),
+			infinity_datetime,
+			negative_infinity_datetime,
 		],
 	),
 	('date', [
@@ -195,6 +199,8 @@
 			datetime.datetime(1950,1,1,10,10,0, tzinfo=FixedOffset(7000)),
 			datetime.datetime(1800,1,1,10,10,0, tzinfo=FixedOffset(2000)),
 			datetime.datetime(2400,1,1,10,10,0, tzinfo=FixedOffset(2000)),
+			infinity_datetime,
+			negative_infinity_datetime,
 		],
 	),
 	('timetz', [
@@ -203,11 +209,13 @@
 			datetime.time(10,10,0, tzinfo=FixedOffset(6000)),
 			datetime.time(10,10,0, tzinfo=FixedOffset(7000)),
 			datetime.time(10,10,0, tzinfo=FixedOffset(2000)),
+			datetime.time(22,30,0, tzinfo=FixedOffset(0)),
 		],
 	),
 	('interval', [
 			# no months :(
 			datetime.timedelta(40, 10, 1234),
+			datetime.timedelta(0, 0, 4321),
 			datetime.timedelta(0, 0),
 			datetime.timedelta(-100, 0),
 			datetime.timedelta(-100, -400),
@@ -273,10 +281,6 @@
 			Varbit('010111101111'),
 		],
 	),
-	('uuid', [
-			uuid.uuid1(),
-		],
-	),
 ]
 
 if False:
@@ -1024,6 +1028,30 @@ def testXML(self):
 			(tostr(foo), tostr(bar))
 		)
 
+	def testUUID(self):
+		# doesn't exist in all versions supported by py-postgresql.
+		has_uuid = self.db.prepare(
+			"select true from pg_type where lower(typname) = 'uuid'").first()
+		if has_uuid:
+			ps = self.db.prepare('select $1::uuid').first
+			x = uuid.uuid1()
+			self.failUnlessEqual(ps(x), x)
+
+	def testInfinity_stdlib_datetime(self):
+		ps = self.db.prepare('SELECT $1::timestamp, $2::timestamptz').first
+		# Can't test the special text case because we don't get the text back.
+		ts, tstz = ps('infinity', 'infinity')
+		self.failUnlessEqual(ts, infinity_datetime)
+		self.failUnlessEqual(tstz, infinity_datetime)
+		ts, tstz = ps('-infinity', '-infinity')
+		self.failUnlessEqual(ts, negative_infinity_datetime)
+		self.failUnlessEqual(tstz, negative_infinity_datetime)
+
+	def testInfinity_stdlib_date(self):
+		ps = self.db.prepare('SELECT $1::date::text').first
+		self.failUnlessEqual(ps('infinity'), 'infinity')
+		self.failUnlessEqual(ps('-infinity'), '-infinity')
+
 	def testTypeIOError(self):
 		original = dict(self.db.typio._cache)
 		ps = self.db.prepare('SELECT $1::numeric')

postgresql/types/io/lib.py

@@ -60,6 +60,15 @@ def path_unpack(data, long_unpack = long_unpack, unpack = struct.unpack):
 	return unpack("!4x%dd" %(long_unpack(data[:4]),), data)
 polygon_pack, polygon_unpack = path_pack, path_unpack
 
+##
+# Binary representations of infinity for datetimes.
+time_infinity = b'\x7f\xf0\x00\x00\x00\x00\x00\x00'
+time_negative_infinity = b'\xff\xf0\x00\x00\x00\x00\x00\x00'
+time64_infinity = b'\x7f\xff\xff\xff\xff\xff\xff\xff'
+time64_negative_infinity = b'\x80\x00\x00\x00\x00\x00\x00\x00'
+date_infinity = b'\x7f\xff\xff\xff'
+date_negative_infinity = b'\x80\x00\x00\x00'
+
 # time types
 date_pack, date_unpack = long_pack, long_unpack
 

postgresql/types/io/stdlib_datetime.py

@@ -1,28 +1,17 @@
 ##
-# datetime - timewise
+# stdlib_datetime - support for the stdlib's datetime.
 #
 # I/O routines for date, time, timetz, timestamp, timestamptz, and interval.
 # Supported by the datetime module.
 ##
-"""
- time_io
-  Floating-point based time I/O.
-
- time_noday_io
-  Floating-point based time I/O with noday-intervals.
-
- time64_io
-  long-long based time I/O.
-
- time64_noday_io
-  long-long based time I/O with noday-intervals.
-"""
 import datetime
 import warnings
 from functools import partial
 from operator import methodcaller, add
 
-from ...python.datetime import UTC, FixedOffset
+from ...python.datetime import UTC, FixedOffset, \
+	infinity_date, infinity_datetime, \
+	negative_infinity_date, negative_infinity_datetime
 from ...python.functools import Composition as compose
 from ...exceptions import TypeConversionWarning
 
@@ -47,18 +36,51 @@
 pg_epoch_datetime = datetime.datetime(2000, 1, 1)
 pg_epoch_date = pg_epoch_datetime.date()
 pg_date_offset = pg_epoch_date.toordinal()
+pg_minus_date_offset = -pg_date_offset
 
 ## Difference between PostgreSQL epoch and Unix epoch.
 ## Used to convert a PostgreSQL ordinal to an ordinal usable by datetime
 pg_time_days = (pg_date_offset - datetime.date(1970, 1, 1).toordinal())
 
-toordinal = methodcaller("toordinal")
 convert_to_utc = methodcaller('astimezone', UTC)
 remove_tzinfo = methodcaller('replace', tzinfo = None)
 set_as_utc = methodcaller('replace', tzinfo = UTC)
 
+##
+# Constants used to special case infinity and -infinity.
+time64_pack_constants = {
+	infinity_datetime: lib.time64_infinity,
+	negative_infinity_datetime: lib.time64_negative_infinity,
+	'infinity': lib.time64_infinity,
+	'-infinity': lib.time64_negative_infinity,
+}
+time_pack_constants = {
+	infinity_datetime: lib.time_infinity,
+	negative_infinity_datetime: lib.time_negative_infinity,
+	'infinity': lib.time_infinity,
+	'-infinity': lib.time_negative_infinity,
+}
+date_pack_constants = {
+	infinity_date: lib.date_infinity,
+	negative_infinity_date: lib.date_negative_infinity,
+	'infinity': lib.date_infinity,
+	'-infinity': lib.date_negative_infinity,
+}
+time64_unpack_constants = {
+	lib.time64_infinity: infinity_datetime,
+	lib.time64_negative_infinity: negative_infinity_datetime,
+}
+time_unpack_constants = {
+	lib.time_infinity: infinity_datetime,
+	lib.time_negative_infinity: negative_infinity_datetime,
+}
+date_unpack_constants = {
+	lib.date_infinity: infinity_date,
+	lib.date_negative_infinity: negative_infinity_date,
+}
+
 date_pack = compose((
-	toordinal, partial(add, -pg_date_offset), lib.date_pack,
+	methodcaller("toordinal"), partial(add, pg_minus_date_offset), lib.date_pack,
 ))
 date_unpack = compose((
 	lib.date_unpack, partial(add, pg_date_offset), datetime.date.fromordinal
@@ -91,7 +113,7 @@ def time_pack(x):
 		x.microsecond
 	)
 
-def time_unpack(seconds_ms, time = datetime.time):
+def time_unpack(seconds_ms, time = datetime.time, divmod = divmod):
 	"""
 	Create a `datetime.time` instance from a (seconds, microseconds) pair.
 	Seconds being offset from epoch.
@@ -106,9 +128,7 @@ def interval_pack(x):
 	Create a (months, days, (seconds, microseconds)) tuple from a
 	`datetime.timedelta` instance.
 	"""
-	return (
-		0, x.days, (x.seconds, x.microseconds)
-	)
+	return (0, x.days, (x.seconds, x.microseconds))
 
 def interval_unpack(mds, timedelta = datetime.timedelta):
 	"""
@@ -117,6 +137,7 @@ def interval_unpack(mds, timedelta = datetime.timedelta):
 	"""
 	months, days, seconds_ms = mds
 	if months != 0:
+		# XXX: Should this raise an exception?
 		w = pg_exc.TypeConversionWarning(
 			"datetime.timedelta cannot represent relative intervals",
 			details = {
@@ -153,6 +174,13 @@ def timetz_unpack(tstz):
 NoDay = True
 WithDay = False
 
+# Used to handle the special cases: infinity and -infinity.
+def proc_when_not_in(proc, dict):
+	def _proc(x):
+		r = dict.get(x)
+		return r or proc(x)
+	return _proc
+
 id_to_io = {
 	(FloatTimes, TIMEOID) : (
 		compose((time_pack, lib.time_pack)),
@@ -165,13 +193,13 @@ def timetz_unpack(tstz):
 		datetime.time
 	),
 	(FloatTimes, TIMESTAMPOID) : (
-		compose((timestamp_pack, lib.time_pack)),
-		compose((lib.time_unpack, timestamp_unpack)),
+		proc_when_not_in(compose((timestamp_pack, lib.time_pack)), time_pack_constants),
+		proc_when_not_in(compose((lib.time_unpack, timestamp_unpack)), time_unpack_constants),
 		datetime.datetime
 	),
 	(FloatTimes, TIMESTAMPTZOID) : (
-		compose((convert_to_utc, remove_tzinfo, timestamp_pack, lib.time_pack)),
-		compose((lib.time_unpack, timestamp_unpack, set_as_utc)),
+		proc_when_not_in(compose((convert_to_utc, remove_tzinfo, timestamp_pack, lib.time_pack)), time_pack_constants),
+		proc_when_not_in(compose((lib.time_unpack, timestamp_unpack, set_as_utc)), time_unpack_constants),
 		datetime.datetime
 	),
 	(FloatTimes, WithDay, INTERVALOID): (
@@ -196,13 +224,13 @@ def timetz_unpack(tstz):
 		datetime.time
 	),
 	(IntTimes, TIMESTAMPOID) : (
-		compose((timestamp_pack, lib.time64_pack)),
-		compose((lib.time64_unpack, timestamp_unpack)),
+		proc_when_not_in(compose((timestamp_pack, lib.time64_pack)), time64_pack_constants),
+		proc_when_not_in(compose((lib.time64_unpack, timestamp_unpack)), time64_unpack_constants),
 		datetime.datetime
 	),
 	(IntTimes, TIMESTAMPTZOID) : (
-		compose((convert_to_utc, remove_tzinfo, timestamp_pack, lib.time64_pack)),
-		compose((lib.time64_unpack, timestamp_unpack, set_as_utc)),
+		proc_when_not_in(compose((convert_to_utc, remove_tzinfo, timestamp_pack, lib.time64_pack)), time64_pack_constants),
+		proc_when_not_in(compose((lib.time64_unpack, timestamp_unpack, set_as_utc)), time64_unpack_constants),
 		datetime.datetime
 	),
 	(IntTimes, WithDay, INTERVALOID) : (
@@ -233,10 +261,14 @@ def select_format(oid, typio, get = id_to_io.__getitem__):
 	return get((time_type(typio), oid))
 
 def select_day_format(oid, typio, get = id_to_io.__getitem__):
-	return get((time_type(typio), typio.database.version_info <= (8,0), oid))
+	return get((time_type(typio), typio.database.version_info[:2] <= (8,0), oid))
 
 oid_to_io = {
-	DATEOID : (date_pack, date_unpack, datetime.date),
+	DATEOID : (
+		proc_when_not_in(date_pack, date_pack_constants),
+		proc_when_not_in(date_unpack, date_unpack_constants),
+		datetime.date,
+	),
 	TIMEOID : select_format,
 	TIMETZOID : select_format,
 	TIMESTAMPOID : select_format,