Failed BEGIN leaves Connection._top_xact set; every later transaction becomes a SAVEPOINT and fails with NoActiveSQLTransactionError #1386

Activity

1. chenty2333 commented on Oct 21, 2026

   

   chenty2333

   on Oct 21, 2026

   More actions

   I reproduced the cancelled-BEGIN variant described above with asyncpg 0.32.0, Python 3.13 and PostgreSQL 18.4. The more subtle failure is a later transaction reporting success while its write remains uncommitted. Three consecutive runs produced the same result.

   Here is a standalone reproduction without SQLAlchemy, a pool or a proxy. Set DATABASE_URL to a disposable database with CREATE TABLE permission:

   """Run with: DATABASE_URL=postgresql://... python asyncpg_entry.py."""
   import asyncio
   import os
   import uuid
   
   async def main():
       dsn = os.environ['DATABASE_URL']
       import asyncpg
       conn = await asyncpg.connect(dsn)
       observer = await asyncpg.connect(dsn)
   
       async def scalar(c, sql):
           return await c.fetchval(sql)
       table = 'entry_cancel_' + uuid.uuid4().hex
       try:
           await observer.execute(f'CREATE TABLE {table} (v integer)')
   
           async def interrupted_entry():
               asyncio.get_running_loop().call_soon(asyncio.current_task().cancel)
               async with conn.transaction():
                   raise AssertionError('transaction body must not be entered')
           try:
               await asyncio.create_task(interrupted_entry())
           except asyncio.CancelledError:
               print('entry cancelled; body not entered')
           await asyncio.sleep(0.1)
           async with conn.transaction():
               await conn.execute(f'INSERT INTO {table} VALUES (42)')
           print('retry transaction exited normally')
           print('same connection:', await scalar(conn, f'SELECT count(*) FROM {table}'))
           print('independent observer:', await scalar(observer, f'SELECT count(*) FROM {table}'))
           await conn.reset()
           async with conn.transaction():
               await conn.execute(f'INSERT INTO {table} VALUES (43)')
           print('observer after reset + fresh transaction:', await scalar(observer, f'SELECT count(*) FROM {table}'))
       finally:
           await conn.close()
           await observer.execute(f'DROP TABLE IF EXISTS {table}')
           await observer.close()
   asyncio.run(asyncio.wait_for(main(), 15))

   Output:

   entry cancelled; body not entered
   retry transaction exited normally
   same connection: 1
   independent observer: 0
   observer after reset + fresh transaction: 1
   

   The final line is a recovery control: after reset(), a fresh transaction commits visibly. The earlier insert was not committed by its successful context exit. This seems worth covering in a regression test alongside the pre-send BEGIN failure case, since simply checking that a subsequent query succeeds misses it.