deev 2.0.2__tar.gz → 2.1.2__tar.gz

{deev-2.0.2/src/deev.egg-info → deev-2.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deev
-Version: 2.0.2
+Version: 2.1.2
 Summary: ..an entity framework for Python.
 Author-email: Shaun Wilson <mrshaunwilson@msn.com>
 License-Expression: MIT
@@ -21,6 +21,8 @@ Provides-Extra: clickhouse
 Requires-Dist: clickhouse-connect[async]>=1.6.0; extra == "clickhouse"
 Provides-Extra: mongodb
 Requires-Dist: pymongo; extra == "mongodb"
+Provides-Extra: mssql
+Requires-Dist: mssql-python>=1.15.0; extra == "mssql"
 Provides-Extra: mysql
 Requires-Dist: mysql-connector-python; extra == "mysql"
 Dynamic: license-file

{deev-2.0.2 → deev-2.1.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "deev"
-version = "2.0.2"
+version = "2.1.2"
 description = "..an entity framework for Python."
 keywords = ["DB", "database", "entity framework", "mapper", "sqlite", "mysql", "mongodb", "clickhouse"]
 authors = [
@@ -27,6 +27,9 @@ clickhouse = [
 mongodb = [
     "pymongo"
 ]
+mssql = [
+    "mssql-python (>=1.15.0)"
+]
 mysql = [
     "mysql-connector-python"
 ]

{deev-2.0.2 → deev-2.1.2}/src/deev/__init__.py

@@ -21,8 +21,8 @@ from .translation import hydrate, splat
 from .utils import connect
 
 
-__version__ = '2.0.2'
-__commit__ = 'a337fba'
+__version__ = '2.1.2'
+__commit__ = 'f71bbe9'
 __all__ = [
     '__version__',
     '__commit__',
@@ -36,6 +36,7 @@ __all__ = [
     'field',
     'hydrate',
     'mongodb',
+    'mssql',
     'mysql',
     'splat',
     'translation',

{deev-2.0.2 → deev-2.1.2}/src/deev/common/connection_string.py

@@ -14,6 +14,7 @@ _DSN_TO_PROVIDER: dict[str, str] = {
     'mongodb': 'mongodb',
     'mongodb+srv': 'mongodb',
     'clickhouse': 'clickhouse',
+    'mssql': 'mssql',
 }
 
 

deev-2.1.2/src/deev/mssql/__init__.py

@@ -0,0 +1,31 @@
+# SPDX-FileCopyrightText: © 2026 Shaun Wilson
+# SPDX-License-Identifier: MIT
+
+try:
+    from .async_mssql_proxy_connection import AsyncMSSQLProxyConnection
+    from .async_mssql_proxy_cursor import AsyncMSSQLProxyCursor
+    from .async_mssql_table_adapter import AsyncMSSQLTableAdapter
+    from .async_mssql_transaction_context import AsyncMSSQLTransactionContext
+    from .mssql_ddl_generator import MSSQLDDLGenerator
+    from .mssql_proxy_connection import MSSQLProxyConnection
+    from .mssql_proxy_cursor import MSSQLProxyCursor
+    from .mssql_table_adapter import MSSQLTableAdapter
+    from .mssql_transaction_context import MSSQLTransactionContext
+    from .mssql_type_mapper import MSSQLTypeMapper
+except Exception:
+    # NOTE: if required packages are not enabled we expect this module to import without errors
+    pass
+
+
+__all__ = [
+    'AsyncMSSQLProxyConnection',
+    'AsyncMSSQLProxyCursor',
+    'AsyncMSSQLTableAdapter',
+    'AsyncMSSQLTransactionContext',
+    'MSSQLDDLGenerator',
+    'MSSQLProxyConnection',
+    'MSSQLProxyCursor',
+    'MSSQLTableAdapter',
+    'MSSQLTransactionContext',
+    'MSSQLTypeMapper'
+]

deev-2.1.2/src/deev/mssql/async_mssql_proxy_connection.py

@@ -0,0 +1,54 @@
+# SPDX-FileCopyrightText: © 2026 Shaun Wilson
+# SPDX-License-Identifier: MIT
+
+from __future__ import annotations
+
+import asyncio
+from mssql_python import Connection
+from types import TracebackType
+from typing import Any, Literal, Self
+
+from ..common.async_db_connection import AsyncDbConnection
+from ..common.async_db_cursor import AsyncDbCursor
+from .async_mssql_proxy_cursor import AsyncMSSQLProxyCursor
+from .mssql_proxy_connection import MSSQLProxyConnection
+
+
+class AsyncMSSQLProxyConnection(AsyncDbConnection):
+    """
+    Async shim that delegates to ``MSSQLProxyConnection``.
+
+    Since mssql_python has no native async API, all calls are forwarded to the
+    synchronous proxy using ``asyncio.to_thread``.
+    """
+
+    __sync_conn: MSSQLProxyConnection
+
+    def __init__(self, conn: Connection) -> None:
+        self.__sync_conn = MSSQLProxyConnection(conn)
+
+    @property
+    def mssql_connection(self) -> MSSQLProxyConnection:
+        return self.__sync_conn
+
+    async def cursor(self, *args: Any, **kwargs: Any) -> AsyncDbCursor:
+        return AsyncMSSQLProxyCursor(self.__sync_conn.cursor(*args, **kwargs))  # type: ignore[arg-type]
+
+    async def commit(self) -> None:
+        await asyncio.to_thread(self.__sync_conn.commit)
+
+    async def rollback(self) -> None:
+        await asyncio.to_thread(self.__sync_conn.rollback)
+
+    async def close(self) -> None:
+        await asyncio.to_thread(self.__sync_conn.close)
+
+    async def __aenter__(self) -> Self:
+        return self
+
+    async def __aexit__(self, exc_type: type[BaseException] | None, exc: BaseException | None, tb: TracebackType | None, /) -> Literal[False]:
+        self.__sync_conn.__exit__(exc_type, exc, tb)
+        return False
+
+
+__all__ = ['AsyncMSSQLProxyConnection']

deev-2.1.2/src/deev/mssql/async_mssql_proxy_cursor.py

@@ -0,0 +1,70 @@
+# SPDX-FileCopyrightText: © 2026 Shaun Wilson
+# SPDX-License-Identifier: MIT
+
+from __future__ import annotations
+
+import asyncio
+from mssql_python import Cursor
+from typing import (
+    Any,
+    Sequence,
+    cast,
+)
+
+from ..common.async_db_cursor import AsyncDbCursor, AsyncDbCursorDescription
+from ..common.db_parameters import DbParameters
+from .mssql_proxy_cursor import MSSQLProxyCursor
+
+
+class AsyncMSSQLProxyCursor(AsyncDbCursor):
+    """
+    Async shim that delegates to ``MSSQLProxyCursor``.
+
+    Wraps the synchronous deev cursor proxy and exposes an async API
+    using ``asyncio.to_thread`` for underlying mssql_python operations.
+    """
+    __sync_cursor: MSSQLProxyCursor
+    __cursor: Cursor
+    __sql_arg_expect: str
+    __sql_arg_subst: str
+
+    def __init__(self, provider_cursor: Cursor) -> None:
+        self.__cursor = provider_cursor
+        self.__sync_cursor = MSSQLProxyCursor(provider_cursor)
+        self.__sql_arg_expect = '%?'
+        self.__sql_arg_subst = '?'
+
+    @property
+    def description(self) -> AsyncDbCursorDescription:
+        return cast(AsyncDbCursorDescription, self.__cursor.description)
+
+    @property
+    def rowcount(self) -> int:
+        return self.__cursor.rowcount
+
+    async def execute(self, operation: str, parameters: DbParameters | None = None) -> None:
+        if parameters is not None:
+            operation = operation.replace(self.__sql_arg_expect, self.__sql_arg_subst)
+        if parameters is None:
+            self.__cursor.execute(operation)
+        else:
+            self.__cursor.execute(operation, parameters)
+
+    async def executemany(self, operation: str, seq_of_parameters: Sequence[DbParameters]) -> None:
+        operation = operation.replace(self.__sql_arg_expect, self.__sql_arg_subst)
+        self.__cursor.executemany(operation, [tuple(p) if isinstance(p, (tuple, list)) else dict(p) for p in seq_of_parameters])  # type: ignore[arg-type]
+
+    async def fetchone(self) -> tuple[Any, ...] | None:
+        return cast(tuple[Any, ...] | None, self.__cursor.fetchone())
+
+    async def fetchmany(self, size: int = 1) -> list[tuple[Any, ...]]:
+        return cast(list[tuple[Any, ...]], self.__cursor.fetchmany(size))
+
+    async def fetchall(self) -> list[tuple[Any, ...]]:
+        return cast(list[tuple[Any, ...]], self.__cursor.fetchall())
+
+    async def close(self) -> None:
+        await asyncio.to_thread(self.__cursor.close)
+
+
+__all__ = ['AsyncMSSQLProxyCursor']

deev-2.1.2/src/deev/mssql/async_mssql_table_adapter.py

@@ -0,0 +1,146 @@
+# SPDX-FileCopyrightText: © 2026 Shaun Wilson
+# SPDX-License-Identifier: MIT
+
+from __future__ import annotations
+
+from typing import Any, AsyncGenerator, TypeVar, cast, get_args, get_origin
+
+from ..common.async_db_table_adapter import AsyncDbTableAdapter
+from ..common.db_context import AsyncDbContext
+from ..common.db_parameters import DbParameters
+from ..entities import get_entity_spec
+from .async_mssql_proxy_connection import AsyncMSSQLProxyConnection
+from .async_mssql_transaction_context import AsyncMSSQLTransactionContext
+from .mssql_proxy_connection import MSSQLProxyConnection
+from .mssql_table_adapter import MSSQLTableAdapter
+from .mssql_type_mapper import MSSQLTypeMapper
+
+TEntity = TypeVar('TEntity')
+
+
+class AsyncMSSQLTableAdapter(AsyncDbTableAdapter[TEntity]):
+    """
+    Async shim that delegates to ``MSSQLTableAdapter``.
+
+    Since mssql_python has no native async API, all calls are forwarded to the
+    synchronous table adapter using ``asyncio.to_thread``.
+    """
+
+    __sync_adapter: MSSQLTableAdapter[TEntity]
+    __context: AsyncDbContext
+    __create_table: bool
+    __table_name: str | None
+
+    def __init__(
+        self,
+        context: AsyncDbContext,
+        *,
+        create_table: bool = False,
+        table_name: str | None = None
+    ) -> None:
+        self.__context = context if isinstance(context, (AsyncMSSQLProxyConnection, AsyncMSSQLTransactionContext)) else AsyncMSSQLProxyConnection(context)  # type: ignore[arg-type]
+        self.__create_table = create_table is True
+        self.__table_name = table_name
+        self.__is_initialized = False
+
+    async def __deferred_init(self) -> None:
+        if not self.__is_initialized:
+            self.__sync_deferred_init()
+            self.__is_initialized = True
+            if self.__create_table is True:
+                await self.create_table()
+
+    def __sync_deferred_init(self) -> None:
+        entity_type = self.__get_typearg(self)
+        self.__entity_spec = get_entity_spec(entity_type)
+        self.__column_names = ', '.join([f'[{k}]' for k in self.__entity_spec.fields.keys()])
+        self.__dbtype_mapper = MSSQLTypeMapper(self.__entity_spec)
+
+        self.__sync_adapter = MSSQLTableAdapter[entity_type](  # type: ignore[valid-type]
+            self.mssql_connection,
+            create_table=self.__create_table,
+            table_name=self.__table_name,
+        )
+
+    @property
+    def primary_key(self) -> tuple[str, ...]:
+        if not hasattr(self, '_AsyncMSSQLTableAdapter__sync_adapter'):
+            self.__sync_deferred_init()
+        return self.__sync_adapter.primary_key
+
+    def __get_typearg(self, obj: object) -> type:
+        orig = getattr(obj, '__orig_class__', None)
+        if orig is not None:
+            args = get_args(orig)
+            if args:
+                return args[0]
+        for base in obj.__class__.__mro__:
+            for generic_base in getattr(base, '__orig_bases__', ()):
+                if get_origin(generic_base) is AsyncMSSQLTableAdapter:
+                    args = get_args(generic_base)
+                    if args is not None and len(args) > 0:
+                        return args[0]
+        raise RuntimeError(
+            f'Could not determine the entity type for {obj.__class__.__qualname__}. '
+            'Instantiate via the generic alias, e.g. AsyncMSSQLTableAdapter[MyEntity]().'
+        )
+
+    @property
+    def mssql_connection(self) -> MSSQLProxyConnection:
+        if isinstance(self.__context, AsyncMSSQLProxyConnection):
+            return self.__context.mssql_connection
+        elif isinstance(self.__context, AsyncMSSQLTransactionContext):
+            return cast(AsyncMSSQLProxyConnection, self.__context.connection).mssql_connection
+        raise RuntimeError(f'unsupported context type: {self.__context}')
+
+    async def create_table(self) -> None:
+        await self.__deferred_init()
+        self.__sync_adapter.create_table()
+        self.__create_table = False
+
+    async def create(self, entity: TEntity | None = None, **kwargs: Any) -> dict[str, Any]:
+        await self.__deferred_init()
+        return self.__sync_adapter.create(entity, **kwargs)
+
+    async def read(self, **kwargs: Any) -> TEntity | None:
+        await self.__deferred_init()
+        return self.__sync_adapter.read(**kwargs)
+
+    async def update(self, entity: TEntity) -> None:
+        await self.__deferred_init()
+        self.__sync_adapter.update(entity)
+
+    async def delete(self, **kwargs: Any) -> None:
+        await self.__deferred_init()
+        self.__sync_adapter.delete(**kwargs)
+
+    async def exists(self, **kwargs: Any) -> bool:
+        await self.__deferred_init()
+        return self.__sync_adapter.exists(**kwargs)
+
+    async def upsert(self, entity: TEntity) -> dict[str, Any]:
+        await self.__deferred_init()
+        return self.__sync_adapter.upsert(entity)
+
+    async def query(  # type: ignore[override]
+        self,
+        where: str | None = None,
+        parameters: DbParameters | None = None,
+        orderby: str | None = None,
+        limit: int | None = None
+    ) -> AsyncGenerator[TEntity, None]:
+        await self.__deferred_init()
+        sync_gen = self.__sync_adapter.query(where, parameters, orderby, limit)
+        for e in sync_gen:
+            yield e
+
+    async def commit(self) -> None:
+        await self.__deferred_init()
+        self.__sync_adapter.commit()
+
+    async def rollback(self) -> None:
+        await self.__deferred_init()
+        self.__sync_adapter.rollback()
+
+
+__all__ = ['AsyncMSSQLTableAdapter']

deev-2.1.2/src/deev/mssql/async_mssql_transaction_context.py

@@ -0,0 +1,135 @@
+# SPDX-FileCopyrightText: © 2026 Shaun Wilson
+# SPDX-License-Identifier: MIT
+
+from __future__ import annotations
+
+import asyncio
+from types import TracebackType
+from typing import Any, AsyncGenerator, Literal, Self, cast
+
+from ..common.async_db_connection import AsyncDbConnection
+from ..common.async_db_cursor import AsyncDbCursor
+from ..common.async_db_transaction_context import AsyncDbTransactionContext
+from ..common.db_context import AsyncDbContext
+from ..common.db_parameters import DbParameters
+from .async_mssql_proxy_connection import AsyncMSSQLProxyConnection
+from .async_mssql_proxy_cursor import AsyncMSSQLProxyCursor
+from .mssql_transaction_context import MSSQLTransactionContext
+
+
+class AsyncMSSQLTransactionContext(AsyncDbTransactionContext):
+    """
+    Async shim that delegates to ``MSSQLTransactionContext``.
+
+    Wraps the synchronous transaction context and exposes an async API
+    using direct method calls — no ``asyncio.to_thread``.
+    """
+
+    __context: AsyncDbContext | None
+    __inner_ctx: MSSQLTransactionContext | None
+    __owns_context: bool
+
+    def __init__(self, context: AsyncDbContext, *, owns_context: bool | None = None) -> None:
+        self.__owns_context = owns_context is True
+        self.__is_deev_context = isinstance(context, (AsyncMSSQLProxyConnection, AsyncMSSQLTransactionContext))
+        self.__context = context if self.__is_deev_context else AsyncMSSQLProxyConnection(context)  # type: ignore[arg-type]
+        self.__inner_ctx = None
+
+    def __del__(self) -> None:
+        try:
+            try:
+                loop = asyncio.get_running_loop()
+            except RuntimeError:
+                loop = None
+            if loop and loop.is_running():
+                loop.create_task(self.close())
+            else:
+                asyncio.run(self.close())
+        except Exception:
+            pass
+
+    def __get_inner_ctx(self) -> MSSQLTransactionContext:
+        """Return the underlying sync transaction context, acquiring it if necessary."""
+        if self.__inner_ctx is None:
+            self.__inner_ctx = MSSQLTransactionContext(
+                context=cast(AsyncMSSQLProxyConnection, self.__context).mssql_connection,
+                owns_context=self.__owns_context
+            )
+        return self.__inner_ctx
+
+    async def __aenter__(self) -> Self:
+        innser_ctx = self.__get_inner_ctx()
+        innser_ctx.__enter__()
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None = None,
+        exc_value: BaseException | None = None,
+        traceback: TracebackType | None = None
+    ) -> Literal[False]:
+        if self.__inner_ctx is not None:
+            self.__inner_ctx.__exit__(exc_type, exc_value, traceback)
+        await self.close()
+        return False
+
+    @property
+    def connection(self) -> AsyncDbConnection:
+        if isinstance(self.__context, AsyncDbTransactionContext):
+            return cast(AsyncDbTransactionContext, self.__context).connection
+        else:
+            return cast(AsyncDbConnection, self.__context)
+
+    @property
+    def transaction_name(self) -> str | None:
+        return self.__get_inner_ctx().transaction_name
+
+    @property
+    def savepoints(self) -> tuple[str, ...]:
+        return self.__get_inner_ctx().savepoints
+
+    async def begin_transaction(self, name: str | None = None) -> Self:
+        self.__get_inner_ctx().begin_transaction(name)
+        return self
+
+    async def create_savepoint(self, name: str | None = None) -> Self:
+        self.__get_inner_ctx().create_savepoint(name)
+        return self
+
+    async def rollback_savepoint(self, name: str | None = None) -> None:
+        self.__get_inner_ctx().rollback_savepoint(name)
+
+    async def close(self) -> None:
+        if self.__inner_ctx is not None:
+            self.__inner_ctx.close()
+
+    async def commit(self) -> None:
+        self.__get_inner_ctx().commit()
+
+    async def cursor(self) -> Any:
+        sync_cursor = self.__get_inner_ctx().cursor()
+        raw_cursor = sync_cursor._MSSQLProxyCursor__cursor  # type: ignore[attr-defined]
+        return AsyncMSSQLProxyCursor(raw_cursor)
+
+    async def execute(self, sql: str, parameters: DbParameters | None = None, raw: bool | None = False) -> Any:
+        return self.__get_inner_ctx().execute(sql, parameters, raw)
+
+    async def execute_nonquery(self, sql: str, parameters: DbParameters | None = None) -> None:
+        self.__get_inner_ctx().execute_nonquery(sql, parameters)
+
+    async def execute_reader(self, sql: str, parameters: DbParameters | None = None) -> AsyncGenerator[tuple[Any, ...], None]:  # type: ignore[override]
+        sync_gen = self.__get_inner_ctx().execute_reader(sql, parameters)
+        for row in sync_gen:
+            yield row
+
+    async def execute_scalar(self, sql: str, parameters: DbParameters | None = None) -> Any:
+        return self.__get_inner_ctx().execute_scalar(sql, parameters)
+
+    async def execute_script(self, sql: str, raw: bool = False) -> None:
+        self.__get_inner_ctx().execute_script(sql, raw)
+
+    async def rollback(self, name: str | None = None) -> None:
+        self.__get_inner_ctx().rollback(name)
+
+
+__all__ = ['AsyncMSSQLTransactionContext']

deev-2.1.2/src/deev/mssql/mssql_ddl_generator.py

@@ -0,0 +1,91 @@
+# SPDX-FileCopyrightText: © 2026 Shaun Wilson
+# SPDX-License-Identifier: MIT
+
+from __future__ import annotations
+
+import hanaro
+import logging
+
+from ..entities import EntitySpec, IndexOrder
+from .mssql_type_mapper import MSSQLTypeMapper
+
+
+class MSSQLDDLGenerator:
+    """
+    Generates Data Definition Language (DDL) statements for Microsoft SQL Server.
+    """
+
+    __logger: logging.Logger
+
+    def __init__(
+        self,
+    ) -> None:
+        self.__logger = hanaro.get_logger()
+
+    def __generate_table_indexes_ddl(self, entity_spec: EntitySpec, table_name: str) -> list[str]:
+        """
+        Build ``CREATE INDEX`` statements for all secondary indexes.
+
+        :param entity_spec: The entity specification containing index metadata.
+        :param table_name: The target table name.
+        :returns: A list of ``CREATE INDEX`` SQL statements.
+        """
+        ddl = list[str]()
+        direction_map = {IndexOrder.ASCENDING: 'ASC', IndexOrder.DESCENDING: 'DESC'}
+        groups: dict[str, list[tuple[str, IndexOrder]]] = {}
+        for field_name, spec in entity_spec.fields.items():
+            if spec.index is None:
+                continue
+            idx_name = spec.index.name
+            direction = spec.index.direction or IndexOrder.ASCENDING
+            groups.setdefault(idx_name, []).append((field_name, direction))
+
+        for idx_name, col_specs in sorted(groups.items()):
+            col_specs.sort(key=lambda cs: cs[0])  # type: ignore
+            cols = ', '.join(f'[{name}] {direction_map[direction]}' for name, direction in col_specs)
+            ddl.append(f'CREATE INDEX [{idx_name}] ON [{table_name}] ({cols})')
+        return ddl
+
+    def generate_table_ddl(
+        self,
+        *,
+        entity_spec: EntitySpec,
+        table_name: str | None = None
+    ) -> list[str]:
+        """
+        Generate DDL statements to create the table and its indexes.
+
+        :param entity_spec: The entity specification describing the table structure.
+        :param table_name: Optional override for the table name.
+        :returns: A list of DDL SQL statements.
+        """
+        db_type_mapper = MSSQLTypeMapper(entity_spec)
+        ddl = list[str]()
+        table_name = entity_spec.table_name if table_name is None else table_name
+        if len(entity_spec.primary_key) == 1:
+            primary_key = entity_spec.primary_key[0]
+            id_dbtype = db_type_mapper.get_provider_type(primary_key)
+            columns = ', '.join([
+                f'[{k}] {db_type_mapper.get_provider_type(k)}'
+                for k in entity_spec.attrs.keys()
+                if k != primary_key
+            ])
+            auto_increment = f' IDENTITY(1,1)' if id_dbtype in ('INT', 'BIGINT', 'SMALLINT') else ''
+            ddl.append(f'CREATE TABLE [{table_name}] ({primary_key} {id_dbtype}{auto_increment}, {columns}, PRIMARY KEY ({primary_key}))')
+        else:
+            columns = ', '.join([
+                f'[{k}] {db_type_mapper.get_provider_type(k)}'
+                for k in entity_spec.attrs.keys()
+            ])
+            primary_key = (
+                f", PRIMARY KEY ({','.join(entity_spec.primary_key)})"
+                if len(entity_spec.primary_key) > 0
+                else ''
+            )
+            ddl.append(f'CREATE TABLE [{table_name}] ({columns}{primary_key})')
+        for e in self.__generate_table_indexes_ddl(entity_spec, table_name):
+            ddl.append(e)
+        return ddl
+
+
+__all__ = ['MSSQLDDLGenerator']

deev-2.1.2/src/deev/mssql/mssql_proxy_connection.py

@@ -0,0 +1,73 @@
+# SPDX-FileCopyrightText: © 2026 Shaun Wilson
+# SPDX-License-Identifier: MIT
+
+from __future__ import annotations
+
+from mssql_python import Connection
+from types import TracebackType
+from typing import Any, Literal, Self
+
+from ..common.db_connection import DbConnection
+from ..common.db_cursor import DbCursor
+from .mssql_proxy_cursor import MSSQLProxyCursor
+
+
+class MSSQLProxyConnection(DbConnection):
+    """
+    DB-API 2.0 compliant connection interface for ``mssql_python``.
+    """
+
+    __connection: Connection
+
+    def __init__(self, provider_connection: Connection) -> None:
+        """
+        Initialize a new MSSQLProxyConnection.
+
+        :param provider_connection: A raw mssql_python Connection instance.
+        """
+        self.__connection = provider_connection
+
+    @property
+    def mssql_connection(self) -> Connection:
+        """
+        Access the underlying raw mssql_python connection.
+
+        :returns: The :class:`mssql_python.Connection` instance.
+        """
+        return self.__connection
+
+    def cursor(self, *args: Any, **kwargs: Any) -> DbCursor:
+        """
+        Create a new cursor for executing SQL statements.
+
+        :returns: A :class:`MSSQLProxyCursor` instance.
+        """
+        return MSSQLProxyCursor(self.__connection.cursor(*args, **kwargs))
+
+    def commit(self) -> None:
+        """Commit the current transaction."""
+        self.__connection.commit()
+
+    def rollback(self) -> None:
+        """Rollback the current transaction."""
+        self.__connection.rollback()
+
+    def close(self) -> None:
+        """Close the database connection."""
+        self.__connection.close()
+
+    def __enter__(self) -> Self:
+        return self
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc: BaseException | None,
+        tb: TracebackType | None,
+        /
+    ) -> Literal[False]:
+        self.__connection.__exit__(exc_type, exc, tb)  # type: ignore[arg-type]
+        return False
+
+
+__all__ = ['MSSQLProxyConnection']