Expose structured error fields as exception attributes

Exception instances can now have the following attributes:

 * severity
 * sqlstate
 * message
 * detail
 * hint
 * position
 * query
 * internal_position
 * internal_query
 * context
 * schema_name
 * table_name
 * column_name
 * data_type_name
 * constraint_name
 * server_source_filename
 * server_source_line
 * server_source_function

Refer to [1] for the meaning of these fields.

[1] https://www.postgresql.org/docs/current/static/protocol-error-fields.html

Author: elprans

asyncpg/exceptions.py

@@ -3,6 +3,25 @@
 
 class ErrorMeta(type):
     _error_map = {}
+    _field_map = {
+        'S': 'severity',
+        'C': 'sqlstate',
+        'M': 'message',
+        'D': 'detail',
+        'H': 'hint',
+        'P': 'position',
+        'p': 'internal_position',
+        'q': 'internal_query',
+        'W': 'context',
+        's': 'schema_name',
+        't': 'table_name',
+        'c': 'column_name',
+        'd': 'data_type_name',
+        'n': 'constraint_name',
+        'F': 'server_source_filename',
+        'L': 'server_source_line',
+        'R': 'server_source_function'
+    }
 
     def __new__(mcls, name, bases, dct):
         global __all__
@@ -11,6 +30,10 @@ def __new__(mcls, name, bases, dct):
         if cls.__module__ == 'asyncpg.exceptions':
             __all__ += (name,)
 
+            if name == 'Error':
+                for f in mcls._field_map.values():
+                    setattr(cls, f, None)
+
         code = dct.get('code')
         if code is not None:
             mcls._error_map[code] = cls
@@ -23,7 +46,33 @@ def get_error_for_code(mcls, code):
 
 
 class Error(Exception, metaclass=ErrorMeta):
-    pass
+    def __str__(self):
+        msg = self.message
+        if self.detail:
+            msg += '\nDETAIL:  {}'.format(self.detail)
+        if self.hint:
+            msg += '\nHINT:  {}'.format(self.hint)
+
+        return msg
+
+    @classmethod
+    def new(cls, fields, query=None):
+        errcode = fields.get('C')
+        mcls = cls.__class__
+        exccls = mcls.get_error_for_code(errcode)
+        mapped = {
+            'query': query
+        }
+
+        for k, v in fields.items():
+            field = mcls._field_map.get(k)
+            if field:
+                mapped[field] = v
+
+        e = exccls(mapped.get('message'))
+        e.__dict__.update(mapped)
+
+        return e
 
 
 class FatalError(Error):

asyncpg/protocol/coreproto.pxd

@@ -89,9 +89,6 @@ cdef class CoreProtocol:
         str _encoding
 
         ####### Connection State:
-
-        ConnectionSettings _settings
-
         int _backend_pid
         int _backend_secret
 

asyncpg/protocol/prepared_stmt.pxd

@@ -1,6 +1,7 @@
 cdef class PreparedStatementState:
     cdef:
         readonly str name
+        readonly str query
         list         row_desc
         list         parameters_desc
 

asyncpg/protocol/prepared_stmt.pyx

@@ -51,8 +51,9 @@ cdef class Record:
 
 cdef class PreparedStatementState:
 
-    def __cinit__(self, str name, BaseProtocol protocol):
+    def __cinit__(self, str name, str query, BaseProtocol protocol):
         self.name = name
+        self.query = query
         self.protocol = protocol
         self.settings = protocol._settings
         self.row_desc = self.parameters_desc = None

asyncpg/protocol/protocol.pxd

@@ -29,11 +29,12 @@ cdef class BaseProtocol(CoreProtocol):
 
     cdef:
         object _loop
-
-        object _connect_waiter
-        object _waiter
         object _address
         tuple  _hash
+        ConnectionSettings _settings
+        str _last_query
+        object _connect_waiter
+        object _waiter
 
         ProtocolState _state
 

asyncpg/protocol/protocol.pyx

@@ -58,7 +58,7 @@ cdef class BaseProtocol(CoreProtocol):
         self._address = address
         self._hash = (self._address, self._database)
         self._settings = ConnectionSettings(self._hash)
-
+        self._last_query = None
         self._connect_waiter = connect_waiter
         self._waiter = None
         self._state = STATE_NOT_CONNECTED
@@ -74,6 +74,7 @@ cdef class BaseProtocol(CoreProtocol):
     def query(self, query):
         self._start_state(STATE_QUERY)
         self._waiter = self._create_future()
+        self._last_query = query
         self._query(query)
         return self._waiter
 
@@ -85,7 +86,7 @@ cdef class BaseProtocol(CoreProtocol):
         if self._prepared_stmt is not None:
             raise RuntimeError('another prepared statement is set')
 
-        self._prepared_stmt = PreparedStatementState(name, self)
+        self._prepared_stmt = PreparedStatementState(name, query, self)
 
         self._waiter = self._create_future()
         self._parse(name, query)
@@ -99,6 +100,8 @@ cdef class BaseProtocol(CoreProtocol):
         self._start_state(STATE_EXECUTE)
         self._prepared_stmt = <PreparedStatementState>state
 
+        self._last_query = self._prepared_stmt.query
+
         self._bind(
             "",
             state.name,
@@ -156,11 +159,8 @@ cdef class BaseProtocol(CoreProtocol):
 
         if result.status == PGRES_FATAL_ERROR:
             self._prepared_stmt = None
-            msg = '\n'.join(['{}: {}'.format(k, v)
-                for k, v in result.err_fields.items()])
-            exc_cls = exceptions.ErrorMeta.get_error_for_code(
-                result.err_fields.get('C'))
-            exc = exc_cls(msg)
+            exc = exceptions.Error.new(result.err_fields,
+                                       query=self._last_query)
             waiter.set_exception(exc)
             self._state = STATE_READY
             self._waiter = None

tests/test_exceptions.py

@@ -7,3 +7,14 @@ class TestExceptions(tb.ConnectedTestCase):
     def test_exceptions_exported(self):
         self.assertTrue(hasattr(asyncpg, 'ConnectionError'))
         self.assertIn('ConnectionError', asyncpg.__all__)
+
+    async def test_exceptions_unpacking(self):
+        with self.assertRaises(asyncpg.Error):
+            try:
+                await self.con.execute('SELECT * FROM _nonexistent_')
+            except asyncpg.Error as e:
+                self.assertEqual(e.sqlstate, '42P01')
+                self.assertEqual(e.position, '15')
+                self.assertEqual(e.query, 'SELECT * FROM _nonexistent_')
+                self.assertIsNotNone(e.severity)
+                raise