Relocate the container factories back into TypeIO.

James William Pye · James William Pye · commit 66a46d65028d · 2010-03-18T15:54:00.000-07:00
The relationship is too close to keep them so far apart.

This is a requisite for getting custom row factories.
diff --git a/postgresql/driver/pg_type.py b/postgresql/driver/pg_type.py
@@ -1,5 +1,5 @@
 ##
-# driver.pg_type - Standard Database Type I/O
+# .driver.pg_type - Standard Database Type I/O
 ##
 from codecs import lookup as lookup_codecs
 from abc import ABCMeta, abstractmethod
@@ -10,8 +10,10 @@
 from ..string import quote_ident
 from .. import types as pg_types
 from ..types.io import resolve
-from ..types.io.pg_container import record_io_factory, array_io_factory
 from ..types import Row, Array, oid_to_sql_name, oid_to_name
+from ..python.functools import process_tuple
+from .. import exceptions as pg_exc
+from ..types.io import lib
 
 class TypeIO(object, metaclass = ABCMeta):
 	"""
@@ -87,6 +89,9 @@ def __init__(self):
 		}
 		self.typinfo = {}
 
+	def row_type_factory(self, column_names):
+		pass
+
 	def sql_type_from_oid(self, oid, qi = quote_ident):
 		if oid in oid_to_sql_name:
 			return oid_to_sql_name[oid]
@@ -163,20 +168,20 @@ def resolve(self,
 						)
 						cio.append((pack or self.encode, unpack or self.decode))
 						i += 1
-					self._cache[typid] = typio = record_io_factory(
+					self._cache[typid] = typio = self.record_io_factory(
 						cio, typids, attmap, list(
 							map(self.sql_type_from_oid, typids)
 						), attnames,
 						quote_ident(typnamespace) + '.' + \
 						quote_ident(typname),
 					)
 				elif ae_typid is not None:
-					# Array Type
+					# resolve the element type and I/O pair
 					te = self.resolve(
 						int(typelem),
 						from_resolution_of = list(from_resolution_of) + [typid]
 					) or (None, None)
-					typio = array_io_factory(
+					typio = self.array_io_factory(
 						te[0] or self.encode,
 						te[1] or self.decode,
 						typelem,
@@ -206,3 +211,132 @@ def identify(self, **identity_mappings):
 			(oid, io if io.__class__ is tuple else io(oid, self))
 			for oid, io in zip(oids, ios)
 		])
+
+	def array_parts(self, array, ArrayType = Array):
+		if array.__class__ is not ArrayType:
+			# Assume the data is a nested list.
+			array = ArrayType(array)
+		return (
+			array.elements(),
+			array.dimensions,
+			array.lowerbounds
+		)
+
+	def array_from_parts(self, parts, ArrayType = Array):
+		elements, dimensions, lowerbounds = parts
+		return ArrayType.from_elements(
+			elements,
+			lowerbounds = lowerbounds,
+			upperbounds = [x + lb - 1 for x, lb in zip(dimensions, lowerbounds)]
+		)
+
+	##
+	# array_io_factory - build I/O pair for ARRAYs
+	##
+	def array_io_factory(
+		self,
+		pack_element, unpack_element,
+		typoid, # array element id
+		hasbin_input, hasbin_output,
+		array_pack = lib.array_pack,
+		array_unpack = lib.array_unpack,
+	):
+		packed_typoid = lib.ulong_pack(typoid)
+		if hasbin_input:
+			def pack_an_array(data, get_parts = self.array_parts):
+				elements, dimensions, lowerbounds = get_parts(data)
+				return array_pack((
+					0, # unused flags
+					typoid, dimensions, lowerbounds,
+					(x if x is None else pack_element(x) for x in elements),
+				))
+		else:
+			# signals string formatting
+			pack_an_array = None
+
+		if hasbin_output:
+			def unpack_an_array(data, array_from_parts = self.array_from_parts):
+				flags, typoid, dims, lbs, elements = array_unpack(data)
+				return array_from_parts((map(unpack_element, elements), dims, lbs))
+		else:
+			# signals string formatting
+			unpack_an_array = None
+
+		return (pack_an_array, unpack_an_array, Array)
+
+	##
+	# record_io_factory - Build an I/O pair for RECORDs
+	##
+	def record_io_factory(self,
+		column_io : "sequence (pack,unpack) tuples corresponding to the columns",
+		typids : "sequence of type Oids; index must correspond to the composite's",
+		attmap : "mapping of column name to index number",
+		typnames : "sequence of sql type names in order",
+		attnames : "sequence of attribute names in order",
+		composite_name : "the name of the composite type",
+		get0 = itemgetter(0),
+		get1 = itemgetter(1),
+	):
+		fpack = tuple(map(get0, column_io))
+		funpack = tuple(map(get1, column_io))
+
+		def raise_pack_tuple_error(procs, tup, itemnum):
+			data = repr(tup[itemnum])
+			if len(data) > 80:
+				# Be sure not to fill screen with noise.
+				data = data[:75] + ' ...'
+			raise pg_exc.ColumnError(
+				"failed to pack attribute %d, %s::%s, of composite %s for transfer" %(
+					itemnum,
+					attnames[itemnum],
+					typnames[itemnum],
+					composite_name,
+				),
+				details = {
+					'context': data,
+					'position' : str(itemnum)
+				},
+			)
+
+		def raise_unpack_tuple_error(procs, tup, itemnum):
+			data = repr(tup[itemnum])
+			if len(data) > 80:
+				# Be sure not to fill screen with noise.
+				data = data[:75] + ' ...'
+			raise pg_exc.ColumnError(
+				"failed to unpack attribute %d, %s::%s, of composite %s from wire data" %(
+					itemnum,
+					attnames[itemnum],
+					typnames[itemnum],
+					composite_name,
+				),
+				details = {
+					'context': data,
+					'position' : str(itemnum),
+				},
+			)
+
+		def unpack_a_record(data,
+			unpack = lib.record_unpack,
+			process_tuple = process_tuple,
+			row_from_seq = Row.from_sequence
+		):
+			data = tuple([x[1] for x in unpack(data)])
+			return row_from_seq(
+				attmap, process_tuple(funpack, data, raise_unpack_tuple_error),
+			)
+
+		sorted_atts = sorted(attmap.items(), key = get1)
+		def pack_a_record(data,
+			pack = lib.record_pack,
+			process_tuple = process_tuple,
+		):
+			if isinstance(data, dict):
+				data = [data.get(k) for k,_ in sorted_atts]
+			return pack(
+				tuple(zip(
+					typids,
+					process_tuple(fpack, tuple(data), raise_pack_tuple_error)
+				))
+			)
+		return (pack_a_record, unpack_a_record, Row)
diff --git a/postgresql/types/io/__init__.py b/postgresql/types/io/__init__.py
@@ -32,12 +32,6 @@
 		pg_types.ABSTIMEOID,
 	),
 
-	# Points to the abstract type resolvers
-	'pg_container' : (
-		pg_types.RECORDOID,
-		pg_types.ANYARRAYOID,
-	),
-
 	'pg_bitwise': (
 		pg_types.BITOID,
 		pg_types.VARBITOID,
@@ -78,6 +72,7 @@
 		pg_types.XMLOID,
 	),
 
+	# Must be db.typio.identify(contrib_hstore = 'hstore')'d
 	'contrib_hstore' : (
 		'contrib_hstore',
 	),
diff --git a/postgresql/types/io/pg_container.py b/postgresql/types/io/pg_container.py
