Fix wrong default transaction isolation level

This fixes the issue when the default_transaction_isolation is not "read committed", `transaction(isolation='read_committed')` won't start a transaction in "read committed" isolation level.

asyncpg/connection.py

@@ -228,7 +228,7 @@ def get_settings(self):
  """
  return self._protocol.get_settings()
 
- def transaction(self, *, isolation='read_committed', readonly=False,
+ def transaction(self, *, isolation=None, readonly=False,
  deferrable=False):
  """Create a :class:`~transaction.Transaction` object.
 
@@ -237,7 +237,9 @@ def transaction(self, *, isolation='read_committed', readonly=False,
 
  :param isolation: Transaction isolation mode, can be one of:
  `'serializable'`, `'repeatable_read'`,
- `'read_committed'`.
+ `'read_committed'`. If not specified, the behavior
+ is up to the server and session, which is usually
+ ``read_committed``.
 
  :param readonly: Specifies whether or not this transaction is
  read-only.

asyncpg/transaction.py

@@ -6,6 +6,7 @@
 
 
 import enum
+import warnings
 
 from . import connresource
 from . import exceptions as apg_errors
@@ -36,12 +37,12 @@ class Transaction(connresource.ConnectionResource):
  def __init__(self, connection, isolation, readonly, deferrable):
  super().__init__(connection)
 
- if isolation not in ISOLATION_LEVELS:
+ if isolation and isolation not in ISOLATION_LEVELS:
  raise ValueError(
  'isolation is expected to be either of {}, '
  'got {!r}'.format(ISOLATION_LEVELS, isolation))
 
- if isolation != 'serializable':
+ if isolation and isolation != 'serializable':
  if readonly:
  raise ValueError(
  '"readonly" is only supported for '
@@ -111,19 +112,29 @@ async def start(self):
  else:
  # Nested transaction block
  top_xact = con._top_xact
- if self._isolation != top_xact._isolation:
- raise apg_errors.InterfaceError(
- 'nested transaction has a different isolation level: '
- 'current {!r} != outer {!r}'.format(
- self._isolation, top_xact._isolation))
+ if top_xact._isolation is None:
+ if self._isolation:
+ w = apg_errors.InterfaceWarning(
+ 'nested transaction may have a different isolation '
+ 'level: current {!r}, outer unknown'.format(
+ self._isolation))
+ warnings.warn(w)
+ elif self._isolation:
+ if self._isolation != top_xact._isolation:
+ raise apg_errors.InterfaceError(
+ 'nested transaction has a different isolation level: '
+ 'current {!r} != outer {!r}'.format(
+ self._isolation, top_xact._isolation))
  self._nested = True
 
  if self._nested:
  self._id = con._get_unique_id('savepoint')
  query = 'SAVEPOINT {};'.format(self._id)
  else:
- if self._isolation == 'read_committed':
+ if self._isolation is None:
  query = 'BEGIN;'
+ elif self._isolation == 'read_committed':
+ query = 'BEGIN ISOLATION LEVEL READ COMMITTED;'
  elif self._isolation == 'repeatable_read':
  query = 'BEGIN ISOLATION LEVEL REPEATABLE READ;'
  else:

tests/test_transaction.py

@@ -179,3 +179,68 @@ async def test_transaction_within_manual_transaction(self):
 
  self.assertIsNone(self.con._top_xact)
  self.assertFalse(self.con.is_in_transaction())
+
+ async def test_isolation_level(self):
+ await self.con.reset()
+ default_isolation = await self.con.fetchval(
+ 'SHOW default_transaction_isolation'
+ )
+ isolation_levels = {
+ None: default_isolation,
+ 'read_committed': 'read committed',
+ 'repeatable_read': 'repeatable read',
+ 'serializable': 'serializable',
+ }
+ set_sql = 'SET SESSION CHARACTERISTICS AS TRANSACTION ISOLATION LEVEL '
+ get_sql = 'SHOW TRANSACTION ISOLATION LEVEL'
+ for tx_level in isolation_levels:
+ for conn_level in isolation_levels:
+ with self.subTest(conn=conn_level, tx=tx_level):
+ if conn_level:
+ await self.con.execute(
+ set_sql + isolation_levels[conn_level]
+ )
+ level = await self.con.fetchval(get_sql)
+ self.assertEqual(level, isolation_levels[conn_level])
+ async with self.con.transaction(isolation=tx_level):
+ level = await self.con.fetchval(get_sql)
+ self.assertEqual(
+ level,
+ isolation_levels[tx_level or conn_level],
+ )
+ await self.con.reset()
+
+ async def test_nested_isolation_level(self):
+ isolation_levels = {
+ None,
+ 'read_committed',
+ 'repeatable_read',
+ 'serializable',
+ }
+ for inner in isolation_levels:
+ for outer in isolation_levels:
+ with self.subTest(outer=outer, inner=inner):
+ async with self.con.transaction(isolation=outer):
+ if outer and inner and outer != inner:
+ with self.assertRaisesRegex(
+ asyncpg.InterfaceError,
+ 'current {!r} != outer {!r}'.format(
+ inner, outer
+ )
+ ):
+ async with self.con.transaction(
+ isolation=inner,
+ ):
+ pass
+ elif not outer and inner:
+ with self.assertWarnsRegex(
+ asyncpg.InterfaceWarning,
+ 'current {!r}, outer unknown'.format(inner),
+ ):
+ async with self.con.transaction(
+ isolation=inner,
+ ):
+ pass
+ else:
+ async with self.con.transaction(isolation=inner):
+ pass