fix(sqlserver): fix transaction level tracking, cursor await, and execute options

- Maintain _transaction_level via base begin/commit/rollback in sync and
  async transaction managers; quote savepoint names with format_identifier
- Make AsyncSQLServerTransactionManager inherit AsyncTransactionManager
- Await aioodbc connection.cursor() in _get_cursor so callers receive a
  real Cursor instead of the _ContextManager wrapper
- Merge column_mapping/column_adapters kwargs into ExecutionOptions in
  execute() (sync and async)
- Populate last_insert_id for INSERT via @@IDENTITY (pyodbc exposes no
  lastrowid and SCOPE_IDENTITY is reset across batches)

Author: vistart

src/rhosocial/activerecord/backend/impl/sqlserver/async_backend.py

@@ -183,7 +183,16 @@ async def _get_cursor(self):
             self.log(logging.DEBUG, "No connection, connecting...")
             await self.connect()
 
-        return self._connection.cursor()
+        return await self._connection.cursor()
+
+    async def _get_scope_identity_async(self) -> Optional[int]:
+        """Get the identity value of the last INSERT via @@IDENTITY."""
+        async with await self._get_cursor() as cursor:
+            await cursor.execute("SELECT @@IDENTITY")
+            row = await cursor.fetchone()
+        if row and row[0] is not None:
+            return int(row[0])
+        return None
 
     async def execute(
         self,
@@ -205,17 +214,30 @@ async def execute(
             QueryResult containing the query results
         """
         from rhosocial.activerecord.backend.options import ExecutionOptions, StatementType
-        
+
+        sql_upper = sql.strip().upper()
+
         if options is None:
-            sql_upper = sql.strip().upper()
             if sql_upper.startswith(("SELECT", "WITH", "EXEC", "EXECUTE")):
                 stmt_type = StatementType.DQL
             elif sql_upper.startswith(("INSERT", "UPDATE", "DELETE", "MERGE")):
                 stmt_type = StatementType.DML
             else:
                 stmt_type = StatementType.DDL
-            
-            options = ExecutionOptions(stmt_type=stmt_type)
+
+            column_mapping = kwargs.get("column_mapping")
+            column_adapters = kwargs.get("column_adapters")
+
+            options = ExecutionOptions(
+                stmt_type=stmt_type,
+                column_adapters=column_adapters,
+                column_mapping=column_mapping,
+            )
+        else:
+            if "column_mapping" in kwargs:
+                options.column_mapping = kwargs["column_mapping"]
+            if "column_adapters" in kwargs:
+                options.column_adapters = kwargs["column_adapters"]
 
         if not self._connection:
             await self.connect()
@@ -276,6 +298,12 @@ async def execute(
                 )
 
                 result = self._build_query_result(cursor, data, duration)
+
+                if options.stmt_type == StatementType.DML and sql_upper.startswith("INSERT"):
+                    scope_id = await self._get_scope_identity_async()
+                    if scope_id is not None:
+                        result.last_insert_id = scope_id
+
                 return result
 
         except Exception as e:

src/rhosocial/activerecord/backend/impl/sqlserver/async_transaction.py

@@ -4,10 +4,10 @@
 """
 
 import logging
-from contextlib import asynccontextmanager
-from typing import AsyncGenerator, List, Optional
+from typing import List, Optional
 
 from rhosocial.activerecord.backend.transaction import (
+    AsyncTransactionManager,
     TransactionState,
     IsolationLevel,
     TransactionMode,
@@ -19,40 +19,21 @@
 from .transaction import SQLServerIsolationLevel, ISOLATION_LEVEL_MAP
 
 
-class AsyncSQLServerTransactionManager:
+class AsyncSQLServerTransactionManager(AsyncTransactionManager):
     """Asynchronous SQL Server transaction manager.
 
     Provides async transaction management with savepoint support.
+    Inherits the level tracking, nesting (savepoint-based) and owner-task
+    bookkeeping from the core :class:`AsyncTransactionManager`, while the
+    ``_do_*`` layer emits SQL Server-specific statements.
     """
 
     def __init__(self, backend, logger=None):
-        self._backend = backend
-        self._logger = logger
-        self._state = TransactionState.INACTIVE
+        super().__init__(backend, logger)
         self._savepoints: List[str] = []
         self._sqlserver_isolation_level: Optional[SQLServerIsolationLevel] = None
         self._name: Optional[str] = None
 
-    @property
-    def is_active(self) -> bool:
-        """Check if a transaction is currently active."""
-        return self._state == TransactionState.ACTIVE
-
-    @property
-    def state(self) -> TransactionState:
-        """Get the current transaction state."""
-        return self._state
-
-    @property
-    def isolation_level(self) -> Optional[IsolationLevel]:
-        """Get the current isolation level."""
-        return self._isolation_level
-
-    @isolation_level.setter
-    def isolation_level(self, level: Optional[IsolationLevel]):
-        """Set the isolation level for the next transaction."""
-        self._isolation_level = level
-
     async def begin(
         self,
         isolation_level: Optional[IsolationLevel] = None,
@@ -69,9 +50,6 @@ async def begin(
             name: Optional transaction name
             snapshot: If True, use SNAPSHOT isolation level
         """
-        if self._state == TransactionState.ACTIVE:
-            raise TransactionError("Transaction already active")
-
         if mode == TransactionMode.READ_ONLY:
             raise UnsupportedTransactionModeError(
                 feature="READ ONLY transactions",
@@ -90,16 +68,25 @@ async def begin(
             self._sqlserver_isolation_level = SQLServerIsolationLevel.SNAPSHOT
         elif effective_iso:
             self._sqlserver_isolation_level = ISOLATION_LEVEL_MAP.get(effective_iso)
+        else:
+            self._sqlserver_isolation_level = None
 
-        await self._do_begin()
+        # Base begin() increments _transaction_level first (so is_active is
+        # already True while _do_begin() executes, preventing auto-commit),
+        # issues a real BEGIN at level 1 and a savepoint for nested levels.
+        await super().begin()
 
-        self._state = TransactionState.ACTIVE
-        self._savepoints = []
+        if self._transaction_level == 1:
+            self._savepoints = []
 
-        self._log(logging.DEBUG, f"Async transaction started (isolation={self._sqlserver_isolation_level})")
+        self.log(logging.DEBUG, f"Async transaction started (isolation={self._sqlserver_isolation_level})")
 
     async def _do_begin(self) -> None:
-        """Execute the BEGIN TRANSACTION statement."""
+        """Execute the SET TRANSACTION ISOLATION LEVEL (if any) and BEGIN TRANSACTION."""
+        if self._sqlserver_isolation_level:
+            set_iso_sql = f"SET TRANSACTION ISOLATION LEVEL {self._sqlserver_isolation_level.value}"
+            await self._backend.execute(set_iso_sql)
+
         parts = ["BEGIN TRANSACTION"]
 
         if self._name:
@@ -108,56 +95,68 @@ async def _do_begin(self) -> None:
         sql = " ".join(parts)
         await self._backend.execute(sql)
 
-        if self._sqlserver_isolation_level:
-            set_iso_sql = f"SET TRANSACTION ISOLATION LEVEL {self._sqlserver_isolation_level.value}"
-            await self._backend.execute(set_iso_sql)
+    async def _do_commit(self) -> None:
+        """Execute the COMMIT TRANSACTION statement."""
+        sql = "COMMIT TRANSACTION"
+        if self._name:
+            sql += f" {self._name}"
+        await self._backend.execute(sql)
+
+    async def _do_rollback(self) -> None:
+        """Execute the ROLLBACK TRANSACTION statement."""
+        sql = "ROLLBACK TRANSACTION"
+        if self._name:
+            sql += f" {self._name}"
+        await self._backend.execute(sql)
+
+    async def _do_create_savepoint(self, name: str) -> None:
+        """Create a savepoint using SQL Server's SAVE TRANSACTION syntax."""
+        quoted = self._backend.dialect.format_identifier(name)
+        sql = f"SAVE TRANSACTION {quoted}"
+        await self._backend.execute(sql)
+
+    async def _do_release_savepoint(self, name: str) -> None:
+        """Release a savepoint (no-op in SQL Server)."""
+        if name in self._savepoints:
+            self._savepoints.remove(name)
+
+    async def _do_rollback_savepoint(self, name: str) -> None:
+        """Rollback to a savepoint using SQL Server's ROLLBACK TRANSACTION syntax."""
+        quoted = self._backend.dialect.format_identifier(name)
+        sql = f"ROLLBACK TRANSACTION {quoted}"
+        await self._backend.execute(sql)
 
     async def commit(self) -> None:
         """Commit the current async transaction."""
-        if self._state != TransactionState.ACTIVE:
+        if not self.is_active:
             raise TransactionError("No active transaction to commit")
 
-        self._log(logging.DEBUG, "Committing async transaction")
+        self.log(logging.DEBUG, "Committing async transaction")
 
         try:
-            await self._do_commit()
-            self._state = TransactionState.COMMITTED
-            self._savepoints = []
-
+            await super().commit()
         except Exception as e:
-            self._state = TransactionState.FAILED
-            self._log(logging.ERROR, f"Failed to commit async transaction: {str(e)}")
+            self.log(logging.ERROR, f"Failed to commit async transaction: {str(e)}")
             raise
 
-    async def _do_commit(self) -> None:
-        """Execute the COMMIT TRANSACTION statement."""
-        sql = "COMMIT TRANSACTION"
-        if self._name:
-            sql += f" {self._name}"
-        await self._backend.execute(sql)
-
     async def rollback(self, savepoint: Optional[str] = None) -> None:
         """Rollback the async transaction or to a savepoint.
 
         Args:
             savepoint: If provided, rollback to this savepoint
         """
-        if self._state != TransactionState.ACTIVE:
+        if not self.is_active:
             raise TransactionError("No active transaction to rollback")
 
         if savepoint:
             await self._rollback_to_savepoint(savepoint)
         else:
-            await self._do_rollback()
-            self._state = TransactionState.ROLLED_BACK
-            self._savepoints = []
-
-    async def _do_rollback(self) -> None:
-        """Execute the ROLLBACK TRANSACTION statement."""
-        sql = "ROLLBACK TRANSACTION"
-        if self._name:
-            sql += f" {self._name}"
-        await self._backend.execute(sql)
+            self.log(logging.DEBUG, "Rolling back async transaction")
+            try:
+                await super().rollback()
+            except Exception as e:
+                self.log(logging.ERROR, f"Failed to rollback async transaction: {str(e)}")
+                raise
 
     async def savepoint(self, name: Optional[str] = None) -> str:
         """Create a savepoint within the current async transaction.
@@ -175,27 +174,32 @@ async def savepoint(self, name: Optional[str] = None) -> str:
             name = f"sp_{len(self._savepoints) + 1}"
 
         if name in self._savepoints:
-            self._log(logging.WARNING, f"Savepoint '{name}' already exists")
+            self.log(logging.WARNING, f"Savepoint '{name}' already exists")
 
-        sql = f"SAVE TRANSACTION {name}"
+        quoted = self._backend.dialect.format_identifier(name)
+        sql = f"SAVE TRANSACTION {quoted}"
         await self._backend.execute(sql)
         self._savepoints.append(name)
+        self._active_savepoints.append(name)
 
-        self._log(logging.DEBUG, f"Async savepoint created: {name}")
+        self.log(logging.DEBUG, f"Async savepoint created: {name}")
         return name
 
     async def _rollback_to_savepoint(self, name: str) -> None:
         """Rollback to a specific savepoint."""
         if name not in self._savepoints:
             raise TransactionError(f"Savepoint '{name}' not found")
 
-        sql = f"ROLLBACK TRANSACTION {name}"
+        quoted = self._backend.dialect.format_identifier(name)
+        sql = f"ROLLBACK TRANSACTION {quoted}"
         await self._backend.execute(sql)
 
         idx = self._savepoints.index(name) + 1
         self._savepoints = self._savepoints[:idx]
+        active_idx = self._active_savepoints.index(name) + 1 if name in self._active_savepoints else 0
+        self._active_savepoints = self._active_savepoints[:active_idx]
 
-        self._log(logging.DEBUG, f"Rolled back to async savepoint: {name}")
+        self.log(logging.DEBUG, f"Rolled back to async savepoint: {name}")
 
     async def release_savepoint(self, name: str) -> None:
         """Release a savepoint (no-op in SQL Server).
@@ -205,25 +209,10 @@ async def release_savepoint(self, name: str) -> None:
         """
         if name in self._savepoints:
             self._savepoints.remove(name)
-            self._log(logging.DEBUG, f"Async savepoint released: {name}")
+            if name in self._active_savepoints:
+                self._active_savepoints.remove(name)
+            self.log(logging.DEBUG, f"Async savepoint released: {name}")
 
     def savepoints(self) -> List[str]:
         """Get list of current savepoints."""
         return self._savepoints.copy()
-
-    @asynccontextmanager
-    async def transaction(self):
-        """Async context manager for transaction."""
-        await self.begin()
-        try:
-            yield self
-        except Exception:
-            await self.rollback()
-            raise
-        else:
-            await self.commit()
-
-    def _log(self, level: int, message: str) -> None:
-        """Log a message."""
-        if self._logger:
-            self._logger.log(level, message)

src/rhosocial/activerecord/backend/impl/sqlserver/backend.py

@@ -285,19 +285,39 @@ def execute(
             DatabaseError: For other database errors
         """
         from rhosocial.activerecord.backend.options import ExecutionOptions, StatementType
-        
+
+        sql_upper = sql.strip().upper()
+
         if options is None:
-            sql_upper = sql.strip().upper()
             if sql_upper.startswith(("SELECT", "WITH", "EXEC", "EXECUTE")):
                 stmt_type = StatementType.DQL
             elif sql_upper.startswith(("INSERT", "UPDATE", "DELETE", "MERGE")):
                 stmt_type = StatementType.DML
             else:
                 stmt_type = StatementType.DDL
-            
-            options = ExecutionOptions(stmt_type=stmt_type)
-        
-        return super().execute(sql, params, options=options)
+
+            column_mapping = kwargs.get("column_mapping")
+            column_adapters = kwargs.get("column_adapters")
+
+            options = ExecutionOptions(
+                stmt_type=stmt_type,
+                column_adapters=column_adapters,
+                column_mapping=column_mapping,
+            )
+        else:
+            if "column_mapping" in kwargs:
+                options.column_mapping = kwargs["column_mapping"]
+            if "column_adapters" in kwargs:
+                options.column_adapters = kwargs["column_adapters"]
+
+        result = super().execute(sql, params, options=options)
+
+        if options.stmt_type == StatementType.DML and sql_upper.startswith("INSERT"):
+            scope_id = self.get_scope_identity()
+            if scope_id is not None:
+                result.last_insert_id = scope_id
+
+        return result
 
     def execute_many(self, sql: str, params_list: List[Tuple]) -> QueryResult:
         """Execute the same SQL statement multiple times with different parameters.

src/rhosocial/activerecord/backend/impl/sqlserver/mixins/backend_mixin.py

@@ -26,7 +26,7 @@ def set_identity_insert(self, table: str, on: bool = True) -> None:
 
     def get_scope_identity(self) -> Optional[int]:
         cursor = self._get_cursor()
-        cursor.execute("SELECT SCOPE_IDENTITY()")
+        cursor.execute("SELECT @@IDENTITY")
         row = cursor.fetchone()
         cursor.close()
         if row and row[0] is not None: