SQLAlchemy 2.1.0rc1__cp315-cp315-win_arm64.whl

sqlalchemy/dialects/mssql/mssqlpython.py

@@ -0,0 +1,242 @@
+# dialects/mssql/mssqlpython.py
+# Copyright (C) 2005-2026 the SQLAlchemy authors and contributors
+# <see AUTHORS file>
+#
+# This module is part of SQLAlchemy and is released under
+# the MIT License: https://www.opensource.org/licenses/mit-license.php
+# mypy: ignore-errors
+
+"""
+.. dialect:: mssql+mssqlpython
+    :name: mssqlpython
+    :dbapi: mssql-python
+    :connectstring: mssql+mssqlpython://<username>:<password>@<host>:<port>/<dbname>
+    :url: https://github.com/microsoft/mssql-python
+
+mssql-python is a driver for Microsoft SQL Server produced by Microsoft.
+
+.. versionadded:: 2.1.0b2
+
+
+The driver is generally similar to pyodbc in most aspects as it is based
+on the same ODBC framework.
+
+Connection Strings
+------------------
+
+Examples of connecting with the mssql-python driver::
+
+    from sqlalchemy import create_engine
+
+    # Basic connection
+    engine = create_engine(
+        "mssql+mssqlpython://user:password@hostname/database"
+    )
+
+    # With Windows Authentication
+    engine = create_engine(
+        "mssql+mssqlpython://hostname/database?authentication=ActiveDirectoryIntegrated"
+    )
+
+"""  # noqa
+
+from __future__ import annotations
+
+import re
+from typing import Any
+from typing import Dict
+from typing import List
+from typing import Optional
+from typing import TYPE_CHECKING
+from typing import Union
+
+from .base import MSDialect
+from .pyodbc import _ms_numeric_pyodbc
+from ... import util
+from ...sql import sqltypes
+
+if TYPE_CHECKING:
+    from ... import pool
+    from ...engine import interfaces
+    from ...engine.interfaces import ConnectArgsType
+    from ...engine.interfaces import DBAPIModule
+    from ...engine.interfaces import IsolationLevel
+    from ...engine.interfaces import URL
+
+
+class _MSNumeric_mssqlpython(_ms_numeric_pyodbc, sqltypes.Numeric):
+    pass
+
+
+class _MSFloat_mssqlpython(_ms_numeric_pyodbc, sqltypes.Float):
+    pass
+
+
+class MSDialect_mssqlpython(MSDialect):
+    driver = "mssqlpython"
+    supports_statement_cache = True
+
+    supports_sane_rowcount_returning = True
+    supports_sane_multi_rowcount = True
+    supports_native_uuid = True
+    scope_identity_must_be_embedded = True
+
+    supports_native_decimal = True
+
+    _disconnect_driver_errors = frozenset(
+        {
+            # mssql-python converts the originating SQLSTATE into these
+            # values and exposes them on ``Exception.driver_error``.
+            "Disconnect error",  # 01002
+            "Client unable to establish connection",  # 08001
+            "Connection not open",  # 08003
+            "Connection failure during transaction",  # 08007
+            "Communication link failure",  # 08S01
+            # mssql-python does not map these SQLSTATE values to a
+            # dedicated driver error yet.
+            "An error occurred with SQLSTATE code: 08S02",
+            "An error occurred with SQLSTATE code: 10054",
+            "Connection timeout expired",  # HYT01
+            "Function sequence error",  # HY010
+        }
+    )
+
+    # used by pyodbc _ms_numeric_pyodbc class
+    _need_decimal_fix = True
+
+    colspecs = util.update_copy(
+        MSDialect.colspecs,
+        {
+            sqltypes.Numeric: _MSNumeric_mssqlpython,
+            sqltypes.Float: _MSFloat_mssqlpython,
+        },
+    )
+
+    def __init__(self, enable_pooling=False, **kw):
+        super().__init__(**kw)
+        if not enable_pooling and self.dbapi is not None:
+            self.loaded_dbapi.pooling(enabled=False)
+
+    @classmethod
+    def import_dbapi(cls) -> DBAPIModule:
+        return __import__("mssql_python")
+
+    def create_connect_args(self, url: URL) -> ConnectArgsType:
+        opts = url.translate_connect_args(username="user")
+        opts.update(url.query)
+
+        keys = opts
+
+        query = url.query
+
+        connect_args: Dict[str, Any] = {}
+        connectors: List[str]
+
+        def check_quote(token: str) -> str:
+            if (
+                ";" in str(token)
+                or "}" in str(token)
+                or str(token).startswith("{")
+            ):
+                token = "{%s}" % token.replace("}", "}}")
+            return token
+
+        keys = {k: check_quote(v) for k, v in keys.items()}
+
+        port = ""
+        if "port" in keys and "port" not in query:
+            port = ",%d" % int(keys.pop("port"))
+
+        connectors = []
+
+        connectors.extend(
+            [
+                "Server=%s%s" % (keys.pop("host", ""), port),
+                "Database=%s" % keys.pop("database", ""),
+            ]
+        )
+
+        user = keys.pop("user", None)
+        if user:
+            connectors.append("UID=%s" % user)
+            pwd = keys.pop("password", "")
+            if pwd:
+                connectors.append("PWD=%s" % pwd)
+        else:
+            authentication = keys.pop("authentication", None)
+            if authentication:
+                connectors.append("Authentication=%s" % authentication)
+
+        connectors.extend(
+            ["%s=%s" % (check_quote(k), v) for k, v in keys.items()]
+        )
+
+        return ((";".join(connectors),), connect_args)
+
+    def is_disconnect(
+        self,
+        e: Exception,
+        connection: Optional[
+            Union[pool.PoolProxiedConnection, interfaces.DBAPIConnection]
+        ],
+        cursor: Optional[interfaces.DBAPICursor],
+    ) -> bool:
+        if not isinstance(e, self.loaded_dbapi.Error):
+            return False
+
+        if getattr(e, "driver_error", None) in self._disconnect_driver_errors:
+            return True
+
+        if isinstance(e, self.loaded_dbapi.ProgrammingError):
+            return (
+                "The cursor's connection has been closed." in str(e)
+                or "Attempt to use a closed connection." in str(e)
+                or "Driver Error: Operation cannot be performed" in str(e)
+            )
+
+        if isinstance(e, self.loaded_dbapi.InterfaceError):
+            return bool(
+                re.search(r"Cannot .* on (?:a )?closed connection", str(e))
+            )
+
+        return False
+
+    def retrieve_dbapi_version(
+        self, dbapi: interfaces.DBAPIModule
+    ) -> util.VersionInfo:
+        return util.parse_version_string(dbapi.version)
+
+    def _get_server_version_info(self, connection):
+        vers = connection.exec_driver_sql("select @@version").scalar()
+        m = re.match(r"Microsoft .*? - (\d+)\.(\d+)\.(\d+)\.(\d+)", vers)
+        if m:
+            return tuple(int(x) for x in m.group(1, 2, 3, 4))
+        else:
+            return None
+
+    def get_isolation_level_values(
+        self, dbapi_connection: interfaces.DBAPIConnection
+    ) -> List[IsolationLevel]:
+        return [
+            *super().get_isolation_level_values(dbapi_connection),
+            "AUTOCOMMIT",
+        ]
+
+    def set_isolation_level(
+        self,
+        dbapi_connection: interfaces.DBAPIConnection,
+        level: IsolationLevel,
+    ) -> None:
+        if level == "AUTOCOMMIT":
+            dbapi_connection.autocommit = True
+        else:
+            dbapi_connection.autocommit = False
+            super().set_isolation_level(dbapi_connection, level)
+
+    def detect_autocommit_setting(
+        self, dbapi_conn: interfaces.DBAPIConnection
+    ) -> bool:
+        return bool(dbapi_conn.autocommit)
+
+
+dialect = MSDialect_mssqlpython

sqlalchemy/dialects/mssql/provision.py

@@ -0,0 +1,196 @@
+# dialects/mssql/provision.py
+# Copyright (C) 2005-2026 the SQLAlchemy authors and contributors
+# <see AUTHORS file>
+#
+# This module is part of SQLAlchemy and is released under
+# the MIT License: https://www.opensource.org/licenses/mit-license.php
+# mypy: ignore-errors
+
+from sqlalchemy import inspect
+from sqlalchemy import Integer
+from ... import create_engine
+from ... import exc
+from ...schema import Column
+from ...schema import DropConstraint
+from ...schema import ForeignKeyConstraint
+from ...schema import MetaData
+from ...schema import Table
+from ...testing.provision import create_db
+from ...testing.provision import dbapi_error
+from ...testing.provision import drop_all_schema_objects_pre_tables
+from ...testing.provision import drop_db
+from ...testing.provision import generate_driver_url
+from ...testing.provision import get_temp_table_name
+from ...testing.provision import log
+from ...testing.provision import normalize_sequence
+from ...testing.provision import post_configure_engine
+from ...testing.provision import run_reap_dbs
+from ...testing.provision import temp_table_keyword_args
+
+
+@post_configure_engine.for_db("mssql")
+def post_configure_engine(url, engine, follower_ident):
+    if engine.driver == "pyodbc":
+        engine.dialect.dbapi.pooling = False
+
+
+@generate_driver_url.for_db("mssql")
+def generate_driver_url(url, driver, query_str):
+    backend = url.get_backend_name()
+
+    new_url = url.set(drivername="%s+%s" % (backend, driver))
+
+    if driver == "pymssql" and url.get_driver_name() != "pymssql":
+        new_url = new_url.set(query="")
+    elif driver == "mssqlpython" and url.get_driver_name() != "mssqlpython":
+        new_url = new_url.set(query={"Encrypt": "No"})
+
+    if driver == "aioodbc":
+        new_url = new_url.update_query_dict({"MARS_Connection": "Yes"})
+
+    if query_str:
+        new_url = new_url.update_query_string(query_str)
+
+    try:
+        new_url.get_dialect()
+    except exc.NoSuchModuleError:
+        return None
+    else:
+        return new_url
+
+
+@create_db.for_db("mssql")
+def _mssql_create_db(cfg, eng, ident):
+    with eng.connect().execution_options(isolation_level="AUTOCOMMIT") as conn:
+        conn.exec_driver_sql("create database %s" % ident)
+        conn.exec_driver_sql(
+            "ALTER DATABASE %s SET ALLOW_SNAPSHOT_ISOLATION ON" % ident
+        )
+        conn.exec_driver_sql(
+            "ALTER DATABASE %s SET READ_COMMITTED_SNAPSHOT ON" % ident
+        )
+        conn.exec_driver_sql("use %s" % ident)
+        conn.exec_driver_sql("create schema test_schema")
+        conn.exec_driver_sql("create schema test_schema_2")
+
+
+@drop_db.for_db("mssql")
+def _mssql_drop_db(cfg, eng, ident):
+    with eng.connect().execution_options(isolation_level="AUTOCOMMIT") as conn:
+        _mssql_drop_ignore(conn, ident)
+
+
+def _mssql_drop_ignore(conn, ident):
+    try:
+        # typically when this happens, we can't KILL the session anyway,
+        # so let the cleanup process drop the DBs
+        # for row in conn.exec_driver_sql(
+        #     "select session_id from sys.dm_exec_sessions "
+        #        "where database_id=db_id('%s')" % ident):
+        #    log.info("killing SQL server session %s", row['session_id'])
+        #    conn.exec_driver_sql("kill %s" % row['session_id'])
+        conn.exec_driver_sql("drop database %s" % ident)
+        log.info("Reaped db: %s", ident)
+        return True
+    except exc.DatabaseError as err:
+        log.warning("couldn't drop db: %s", err)
+        return False
+
+
+@run_reap_dbs.for_db("mssql")
+def _reap_mssql_dbs(url, idents):
+    log.info("db reaper connecting to %r", url)
+    eng = create_engine(url)
+    with eng.connect().execution_options(isolation_level="AUTOCOMMIT") as conn:
+        log.info("identifiers in file: %s", ", ".join(idents))
+
+        to_reap = conn.exec_driver_sql(
+            "select d.name from sys.databases as d where name "
+            "like 'TEST_%' and not exists (select session_id "
+            "from sys.dm_exec_sessions "
+            "where database_id=d.database_id)"
+        )
+        all_names = {dbname.lower() for (dbname,) in to_reap}
+        to_drop = set()
+        for name in all_names:
+            if name in idents:
+                to_drop.add(name)
+
+        dropped = total = 0
+        for total, dbname in enumerate(to_drop, 1):
+            if _mssql_drop_ignore(conn, dbname):
+                dropped += 1
+        log.info(
+            "Dropped %d out of %d stale databases detected", dropped, total
+        )
+
+
+@temp_table_keyword_args.for_db("mssql")
+def _mssql_temp_table_keyword_args(cfg, eng):
+    return {}
+
+
+@get_temp_table_name.for_db("mssql")
+def _mssql_get_temp_table_name(cfg, eng, base_name):
+    return "##" + base_name
+
+
+@drop_all_schema_objects_pre_tables.for_db("mssql")
+def drop_all_schema_objects_pre_tables(cfg, eng):
+    with eng.connect().execution_options(isolation_level="AUTOCOMMIT") as conn:
+        inspector = inspect(conn)
+
+        # Drop all full-text indexes before dropping catalogs
+        fulltext_indexes = conn.exec_driver_sql(
+            "SELECT OBJECT_SCHEMA_NAME(object_id) AS schema_name, "
+            "OBJECT_NAME(object_id) AS table_name "
+            "FROM sys.fulltext_indexes"
+        ).fetchall()
+
+        for schema_name, table_name in fulltext_indexes:
+            if schema_name:
+                qualified_name = f"[{schema_name}].[{table_name}]"
+            else:
+                qualified_name = f"[{table_name}]"
+            conn.exec_driver_sql(f"DROP FULLTEXT INDEX ON {qualified_name}")
+
+        # Now drop all full-text catalogs
+        fulltext_catalogs = conn.exec_driver_sql(
+            "SELECT name FROM sys.fulltext_catalogs"
+        ).fetchall()
+
+        for (catalog_name,) in fulltext_catalogs:
+            conn.exec_driver_sql(f"DROP FULLTEXT CATALOG [{catalog_name}]")
+
+        for schema in (None, "dbo", cfg.test_schema, cfg.test_schema_2):
+            for tname in inspector.get_table_names(schema=schema):
+                tb = Table(
+                    tname,
+                    MetaData(),
+                    Column("x", Integer),
+                    Column("y", Integer),
+                    schema=schema,
+                )
+                for fk in inspect(conn).get_foreign_keys(tname, schema=schema):
+                    conn.execute(
+                        DropConstraint(
+                            ForeignKeyConstraint(
+                                [tb.c.x], [tb.c.y], name=fk["name"]
+                            ),
+                        )
+                    )
+
+
+@normalize_sequence.for_db("mssql")
+def normalize_sequence(cfg, sequence):
+    if sequence.start is None:
+        sequence.start = 1
+    return sequence
+
+
+@dbapi_error.for_db("mssql")
+def dbapi_error(cfg, cls, message):
+    if cfg.db.driver == "mssqlpython":
+        return cls(message, "placeholder for mssqlpython")
+    else:
+        return cls(message)

sqlalchemy/dialects/mssql/pymssql.py

@@ -0,0 +1,130 @@
+# dialects/mssql/pymssql.py
+# Copyright (C) 2005-2026 the SQLAlchemy authors and contributors
+# <see AUTHORS file>
+#
+# This module is part of SQLAlchemy and is released under
+# the MIT License: https://www.opensource.org/licenses/mit-license.php
+# mypy: ignore-errors
+
+
+"""
+.. dialect:: mssql+pymssql
+    :name: pymssql
+    :dbapi: pymssql
+    :connectstring: mssql+pymssql://<username>:<password>@<freetds_name>/?charset=utf8
+
+pymssql is a Python module that provides a Python DBAPI interface around
+`FreeTDS <https://www.freetds.org/>`_.
+
+.. versionchanged:: 2.0.5
+
+    pymssql was restored to SQLAlchemy's continuous integration testing
+
+
+"""  # noqa
+
+import re
+
+from .base import MSDialect
+from .base import MSIdentifierPreparer
+from ... import types as sqltypes
+from ... import util
+from ...engine import processors
+
+
+class _MSNumeric_pymssql(sqltypes.Numeric):
+    def result_processor(self, dialect, type_):
+        if not self.asdecimal:
+            return processors.to_float
+        else:
+            return sqltypes.Numeric.result_processor(self, dialect, type_)
+
+
+class MSIdentifierPreparer_pymssql(MSIdentifierPreparer):
+    def __init__(self, dialect):
+        super().__init__(dialect)
+        # pymssql has the very unusual behavior that it uses pyformat
+        # yet does not require that percent signs be doubled
+        self._double_percents = False
+
+
+class MSDialect_pymssql(MSDialect):
+    supports_statement_cache = True
+    supports_native_decimal = True
+    supports_native_uuid = True
+    driver = "pymssql"
+
+    preparer = MSIdentifierPreparer_pymssql
+
+    colspecs = util.update_copy(
+        MSDialect.colspecs,
+        {sqltypes.Numeric: _MSNumeric_pymssql, sqltypes.Float: sqltypes.Float},
+    )
+
+    def retrieve_dbapi_version(self, dbapi):
+        return util.parse_version_string(getattr(dbapi, "__version__", None))
+
+    @classmethod
+    def import_dbapi(cls):
+        module = __import__("pymssql")
+        # pymmsql < 2.1.1 doesn't have a Binary method.  we use string
+        client_ver = util.parse_version_string(module.__version__)
+        if client_ver < (2, 1, 1):
+            # TODO: monkeypatching here is less than ideal
+            module.Binary = lambda x: x if hasattr(x, "decode") else str(x)
+
+        if client_ver < (1,):
+            util.warn(
+                "The pymssql dialect expects at least "
+                "the 1.0 series of the pymssql DBAPI."
+            )
+        return module
+
+    def _get_server_version_info(self, connection):
+        vers = connection.exec_driver_sql("select @@version").scalar()
+        m = re.match(r"Microsoft .*? - (\d+)\.(\d+)\.(\d+)\.(\d+)", vers)
+        if m:
+            return tuple(int(x) for x in m.group(1, 2, 3, 4))
+        else:
+            return None
+
+    def create_connect_args(self, url):
+        opts = url.translate_connect_args(username="user")
+        opts.update(url.query)
+        port = opts.pop("port", None)
+        if port and "host" in opts:
+            opts["host"] = "%s:%s" % (opts["host"], port)
+        return ([], opts)
+
+    def is_disconnect(self, e, connection, cursor):
+        for msg in (
+            "Adaptive Server connection timed out",
+            "Net-Lib error during Connection reset by peer",
+            "message 20003",  # connection timeout
+            "Error 10054",
+            "Not connected to any MS SQL server",
+            "Connection is closed",
+            "message 20006",  # Write to the server failed
+            "message 20017",  # Unexpected EOF from the server
+            "message 20047",  # DBPROCESS is dead or not enabled
+            "The server failed to resume the transaction",
+        ):
+            if msg in str(e):
+                return True
+        else:
+            return False
+
+    def get_isolation_level_values(self, dbapi_connection):
+        return super().get_isolation_level_values(dbapi_connection) + [
+            "AUTOCOMMIT"
+        ]
+
+    def set_isolation_level(self, dbapi_connection, level):
+        if level == "AUTOCOMMIT":
+            dbapi_connection.autocommit(True)
+        else:
+            dbapi_connection.autocommit(False)
+            super().set_isolation_level(dbapi_connection, level)
+
+
+dialect = MSDialect_pymssql