Use raise . from cause to communicate the cause of TypeIO errors.

Per Elvis' patch.

Some additional changes were necessary to optimized's functools, but it
ended up simplifying code by the removal of some PyErr_SetContext calls.

Author: James William Pye

postgresql/driver/pq3.py

@@ -417,7 +417,7 @@ def record_io_factory(self,
 		funpack = tuple(map(get1, column_io))
 		row_constructor = self.RowTypeFactory(attribute_map = attmap, composite_relid = composite_relid)
 
-		def raise_pack_tuple_error(procs, tup, itemnum):
+		def raise_pack_tuple_error(cause, procs, tup, itemnum):
 			data = repr(tup[itemnum])
 			if len(data) > 80:
 				# Be sure not to fill screen with noise.
@@ -428,9 +428,9 @@ def raise_pack_tuple_error(procs, tup, itemnum):
 				(b'M', fmt_errmsg('pack', itemnum, attnames[itemnum], typnames[itemnum], composite_name),),
 				(b'W', data,),
 				(b'P', str(itemnum),)
-			)))
+			)), cause = cause)
 
-		def raise_unpack_tuple_error(procs, tup, itemnum):
+		def raise_unpack_tuple_error(cause, procs, tup, itemnum):
 			data = repr(tup[itemnum])
 			if len(data) > 80:
 				# Be sure not to fill screen with noise.
@@ -441,7 +441,7 @@ def raise_unpack_tuple_error(procs, tup, itemnum):
 				(b'M', fmt_errmsg('unpack', itemnum, attnames[itemnum], typnames[itemnum], composite_name),),
 				(b'W', data,),
 				(b'P', str(itemnum),),
-			)))
+			)), cause = cause)
 
 		def unpack_a_record(data,
 			unpack = io_lib.record_unpack,
@@ -731,12 +731,13 @@ def _process_tuple_chunk_Column(self, x, range = range):
 		r = range(len(l))
 		try:
 			return [unpack(l[i]) for i in r]
-		except:
-			try:
-				i = next(r)
-			except StopIteration:
-				i = len(l)
-			self._raise_column_tuple_error(self._output_io, (l[i],), 0)
+		except Exception:
+			cause = sys.exc_info()[1]
+		try:
+			i = next(r)
+		except StopIteration:
+			i = len(l)
+		self._raise_column_tuple_error(cause, self._output_io, (l[i],), 0)
 
 	# Process the element.Tuple message in x for rows()
 	def _process_tuple_chunk_Row(self, x,
@@ -752,7 +753,7 @@ def _process_tuple_chunk_Row(self, x,
 	def _process_tuple_chunk(self, x, proc = process_chunk):
 		return proc(self._output_io, x, self._raise_column_tuple_error)
 
-	def _raise_column_tuple_error(self, procs, tup, itemnum):
+	def _raise_column_tuple_error(self, cause, procs, tup, itemnum):
 		'for column processing'
 		# The element traceback will include the full list of parameters.
 		data = repr(tup[itemnum])
@@ -775,7 +776,7 @@ def _raise_column_tuple_error(self, procs, tup, itemnum):
 			(b'H', "Try casting the column to 'text'."),
 			(b'P', str(itemnum)),
 		))
-		self.database.typio.raise_client_error(em, creator = self)
+		self.database.typio.raise_client_error(em, creator = self, cause = cause)
 
 	@property
 	def state(self):
@@ -1302,7 +1303,7 @@ def _pq_parameters(self, parameters, proc = process_tuple):
 	# process_tuple failed(exception). The parameters could not be packed.
 	# This function is called with the given information in the context
 	# of the original exception(to allow chaining).
-	def _raise_parameter_tuple_error(self, procs, tup, itemnum):
+	def _raise_parameter_tuple_error(self, cause, procs, tup, itemnum):
 		# Find the SQL type name. This should *not* hit the server.
 		typ = self.database.typio.sql_type_from_oid(
 			self.pg_parameter_types[itemnum]
@@ -1325,11 +1326,11 @@ def _raise_parameter_tuple_error(self, procs, tup, itemnum):
 			(b'H', "Try casting the parameter to 'text', then to the target type."),
 			(b'P', str(itemnum))
 		))
-		self.database.typio.raise_client_error(em, creator = self)
+		self.database.typio.raise_client_error(em, creator = self, cause = cause)
 
 	##
 	# Similar to the parameter variant.
-	def _raise_column_tuple_error(self, procs, tup, itemnum):
+	def _raise_column_tuple_error(self, cause, procs, tup, itemnum):
 		# Find the SQL type name. This should *not* hit the server.
 		typ = self.database.typio.sql_type_from_oid(
 			self.pg_column_types[itemnum]
@@ -1352,7 +1353,7 @@ def _raise_column_tuple_error(self, procs, tup, itemnum):
 			(b'H', "Try casting the column to 'text'."),
 			(b'P', str(itemnum)),
 		))
-		self.database.typio.raise_client_error(em, creator = self)
+		self.database.typio.raise_client_error(em, creator = self, cause = cause)
 
 	@property
 	def state(self) -> str:

postgresql/port/optimized/functools.c

@@ -100,7 +100,6 @@ _process_tuple(PyObject *procs, PyObject *tup, PyObject *fail)
 			 * processed and therefore a generalized exception raised in the
 			 * context of the original is *very* useful.
 			 */
-
 			Py_DECREF(rob);
 			rob = NULL;
 
@@ -109,26 +108,28 @@ _process_tuple(PyObject *procs, PyObject *tup, PyObject *fail)
 			 */
 			if (PyErr_ExceptionMatches(PyExc_Exception))
 			{
-				PyObject *failargs, *failedat;
-				PyObject *exc, *val, *tb;
-				PyObject *oldexc, *oldval, *oldtb;
+				PyObject *cause, *failargs, *failedat;
+				PyObject *exc, *tb;
 
 				/* Store exception to set context after handler. */
-				PyErr_Fetch(&oldexc, &oldval, &oldtb);
-				PyErr_NormalizeException(&oldexc, &oldval, &oldtb);
+				PyErr_Fetch(&exc, &cause, &tb);
+				PyErr_NormalizeException(&exc, &cause, &tb);
+				Py_XDECREF(exc);
+				Py_XDECREF(tb);
 
 				failedat = PyLong_FromSsize_t(i);
 				if (failedat != NULL)
 				{
-					failargs = PyTuple_New(3);
+					failargs = PyTuple_New(4);
 					if (failargs != NULL)
 					{
-						/* args for the exception "handler" */
-						PyTuple_SET_ITEM(failargs, 0, procs);
+						/* args for the exception "generalizer" */
+						PyTuple_SET_ITEM(failargs, 0, cause);
+						PyTuple_SET_ITEM(failargs, 1, procs);
 						Py_INCREF(procs);
-						PyTuple_SET_ITEM(failargs, 1, tup);
+						PyTuple_SET_ITEM(failargs, 2, tup);
 						Py_INCREF(tup);
-						PyTuple_SET_ITEM(failargs, 2, failedat);
+						PyTuple_SET_ITEM(failargs, 3, failedat);
 
 						r = PyObject_CallObject(fail, failargs);
 						Py_DECREF(failargs);
@@ -145,33 +146,6 @@ _process_tuple(PyObject *procs, PyObject *tup, PyObject *fail)
 						Py_DECREF(failedat);
 					}
 				}
-
-				PyErr_Fetch(&exc, &val, &tb);
-				PyErr_NormalizeException(&exc, &val, &tb);
-
-				/*
-				 * Reference BaseException here as the condition is merely
-				 * *validating* that SetContext can be used.
-				 */
-				if (val != NULL && PyObject_IsInstance(val, PyExc_BaseException))
-				{
-					/* Steals oldval reference */
-					PyException_SetContext(val, oldval);
-					Py_XDECREF(oldexc);
-					Py_XDECREF(oldtb);
-					PyErr_Restore(exc, val, tb);
-				}
-				else
-				{
-					/*
-					 * Fetch & NormalizeException failed somehow.
-					 * Use the old exception...
-					 */
-					PyErr_Restore(oldexc, oldval, oldtb);
-					Py_XDECREF(exc);
-					Py_XDECREF(val);
-					Py_XDECREF(tb);
-				}
 			}
 
 			/*

postgresql/python/functools.py

@@ -1,6 +1,7 @@
 ##
 # python.functools
 ##
+import sys
 from .decorlib import method
 
 def rsetattr(attr, val, ob):
@@ -33,7 +34,7 @@ def __call__(self, r):
 	# C implementation of the tuple processors.
 	from ..port.optimized import process_tuple, process_chunk
 except ImportError:
-	def process_tuple(procs, tup, exception_handler, len = len, tuple = tuple):
+	def process_tuple(procs, tup, exception_handler, len = len, tuple = tuple, cause = None):
 		"""
 		Call each item in `procs` with the corresponding
 		item in `tup` returning the result as `type`.
@@ -57,8 +58,10 @@ def process_tuple(procs, tup, exception_handler, len = len, tuple = tuple):
 					continue
 				r[i] = procs[i](ob)
 		except Exception:
-			# relying on __context__
-			exception_handler(procs, tup, i)
+			cause = sys.exc_info()[1]
+
+		if cause is not None:
+			exception_handler(cause, procs, tup, i)
 			raise RuntimeError("process_tuple exception handler failed to raise")
 		return tuple(r)
 

postgresql/test/test_driver.py

@@ -1252,10 +1252,10 @@ def testTypeIOError(self):
 				# 'foo' is not a valid Decimal.
 				# Expecting a double TupleError here, one from the composite pack
 				# and one from the row pack.
-				self.assertTrue(isinstance(err.__context__, pg_exc.CompositeError))
+				self.assertTrue(isinstance(err.__cause__, pg_exc.CompositeError))
 				self.assertEqual(int(err.details['position']), 0)
 				# attribute number that the failure occurred on
-				self.assertEqual(int(err.__context__.details['position']), 0)
+				self.assertEqual(int(err.__cause__.details['position']), 0)
 			else:
 				self.fail("failed to raise TupleError")
 
@@ -1278,7 +1278,7 @@ def raise_ThisError(arg):
 			try:
 				ps(decimal.Decimal("101"))
 			except pg_exc.ColumnError as err:
-				self.assertTrue(isinstance(err.__context__, ThisError))
+				self.assertTrue(isinstance(err.__cause__, ThisError))
 				# might be too inquisitive....
 				self.assertEqual(int(err.details['position']), 0)
 				self.assertTrue('NUMERIC' in err.message)
@@ -1289,11 +1289,11 @@ def raise_ThisError(arg):
 			try:
 				ps((decimal.Decimal("101"),))
 			except pg_exc.ColumnError as err:
-				self.assertTrue(isinstance(err.__context__, pg_exc.CompositeError))
-				self.assertTrue(isinstance(err.__context__.__context__, ThisError))
+				self.assertTrue(isinstance(err.__cause__, pg_exc.CompositeError))
+				self.assertTrue(isinstance(err.__cause__.__cause__, ThisError))
 				# might be too inquisitive....
 				self.assertEqual(int(err.details['position']), 0)
-				self.assertEqual(int(err.__context__.details['position']), 0)
+				self.assertEqual(int(err.__cause__.details['position']), 0)
 				self.assertTrue('test_tuple_error' in err.message)
 			else:
 				self.fail("failed to raise TupleError from reception")

postgresql/test/test_protocol.py

@@ -101,7 +101,7 @@ def test_getvalue(self):
 		b.write(nd)
 		self.assertEqual(b.getvalue(), nd)
 		b.write(packl(4))
-		self.assertEqual(b.read(), [(b'N', b'')])
+		self.assertEqual(list(b.read()), [(b'N', b'')])
 		self.assertEqual(b.getvalue(), b'')
 		# partial; read one message to exercise
 		# that the appropriate fragment of the first
@@ -112,20 +112,20 @@ def test_getvalue(self):
 		second = b'z' + packl(len(second_body) + 4) + second_body
 		b.write(first + second)
 		self.assertEqual(b.getvalue(), first + second)
-		self.assertEqual(b.read(1), [(b'v', first_body)])
+		self.assertEqual(list(b.read(1)), [(b'v', first_body)])
 		self.assertEqual(b.getvalue(), second)
-		self.assertEqual(b.read(1), [(b'z', second_body)])
+		self.assertEqual(list(b.read(1)), [(b'z', second_body)])
 		# now, with a third full message in the next chunk
 		third_body = (b'9876' * 10)
 		third = b'3' + packl(len(third_body) + 4) + third_body
 		b.write(first + second)
 		b.write(third)
 		self.assertEqual(b.getvalue(), first + second + third)
-		self.assertEqual(b.read(1), [(b'v', first_body)])
+		self.assertEqual(list(b.read(1)), [(b'v', first_body)])
 		self.assertEqual(b.getvalue(), second + third)
-		self.assertEqual(b.read(1), [(b'z', second_body)])
+		self.assertEqual(list(b.read(1)), [(b'z', second_body)])
 		self.assertEqual(b.getvalue(), third)
-		self.assertEqual(b.read(1), [(b'3', third_body)])
+		self.assertEqual(list(b.read(1)), [(b'3', third_body)])
 		self.assertEqual(b.getvalue(), b'')
 
 ##

postgresql/test/test_types.py

@@ -340,27 +340,27 @@ def testExpectIO(self, samples):
 			)
 
 class test_io(unittest.TestCase):
-	def test_process_tuple(self, pt = process_tuple):
-		def funpass(procs, tup, col):
+	def test_process_tuple(self):
+		def funpass(cause, procs, tup, col):
 			pass
-		self.assertEqual(tuple(pt((),(), funpass)), ())
-		self.assertEqual(tuple(pt((int,),("100",), funpass)), (100,))
-		self.assertEqual(tuple(pt((int,int),("100","200"), funpass)), (100,200))
-		self.assertEqual(tuple(pt((int,int),(None,"200"), funpass)), (None,200))
-		self.assertEqual(tuple(pt((int,int,int),(None,None,"200"), funpass)), (None,None,200))
+		self.assertEqual(tuple(process_tuple((),(), funpass)), ())
+		self.assertEqual(tuple(process_tuple((int,),("100",), funpass)), (100,))
+		self.assertEqual(tuple(process_tuple((int,int),("100","200"), funpass)), (100,200))
+		self.assertEqual(tuple(process_tuple((int,int),(None,"200"), funpass)), (None,200))
+		self.assertEqual(tuple(process_tuple((int,int,int),(None,None,"200"), funpass)), (None,None,200))
 		# The exception handler must raise.
-		self.assertRaises(RuntimeError, pt, (int,), ("foo",), funpass)
+		self.assertRaises(RuntimeError, process_tuple, (int,), ("foo",), funpass)
 
 		class ThisError(Exception):
 			pass
 		data = []
-		def funraise(procs, tup, col):
+		def funraise(cause, procs, tup, col):
 			data.append((procs, tup, col))
-			raise ThisError
-		self.assertRaises(ThisError, pt, (int,), ("foo",), funraise)
+			raise ThisError from cause
+		self.assertRaises(ThisError, process_tuple, (int,), ("foo",), funraise)
 		self.assertEqual(data[0], ((int,), ("foo",), 0))
 		del data[0]
-		self.assertRaises(ThisError, pt, (int,int), ("100","bar"), funraise)
+		self.assertRaises(ThisError, process_tuple, (int,int), ("100","bar"), funraise)
 		self.assertEqual(data[0], ((int,int), ("100","bar"), 1))
 
 	def testExpectations(self):