dbt-sqlserver 1.11.0rc1__tar.gz → 1.12.0rc2__tar.gz

{dbt_sqlserver-1.11.0rc1 → dbt_sqlserver-1.12.0rc2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dbt-sqlserver
-Version: 1.11.0rc1
+Version: 1.12.0rc2
 Summary: A Microsoft SQL Server adapter plugin for dbt
 Author: Mikael Ene, Anders Swanson, Sam Debruyn, Cor Zuurmond, Cody Scott
 License: MIT
@@ -14,32 +14,45 @@ Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: Microsoft :: Windows
 Classifier: Operating System :: MacOS :: MacOS X
 Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
-Requires-Python: >=3.11
+Classifier: Programming Language :: Python :: 3.14
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: dbt-core<2.0,>=1.11.0
+Requires-Dist: dbt-core<2.0,>=1.12.0
 Requires-Dist: dbt-common<2.0,>=1.22.0
-Requires-Dist: dbt-adapters<2.0,>=1.24.1
-Requires-Dist: pyodbc>=5.2.0
+Requires-Dist: dbt-adapters<2.0,>=1.24.5
 Provides-Extra: azure
 Requires-Dist: azure-identity>=1.12.0; extra == "azure"
 Provides-Extra: pyodbc
 Requires-Dist: pyodbc>=5.2.0; extra == "pyodbc"
 Provides-Extra: mssql
 Requires-Dist: mssql-python>=1.7.1; extra == "mssql"
-Requires-Dist: azure-identity>=1.12.0; extra == "mssql"
-Requires-Dist: azure-core>=1.0.0; extra == "mssql"
+Provides-Extra: adbc
+Requires-Dist: adbc-driver-manager>=1.0.0; extra == "adbc"
+Requires-Dist: pyarrow>=14.0.0; extra == "adbc"
 Dynamic: license-file
 
 # dbt-sqlserver
 
 [dbt](https://www.getdbt.com) adapter for Microsoft SQL Server and Azure SQL services.
 
-The adapter supports dbt-core 1.10 or newer and follows the same versioning scheme.
-E.g. version 1.10.x of the adapter is compatible with dbt-core 1.10.x.
+The adapter supports dbt-core 1.11 or newer and follows the same versioning scheme.
+E.g. version 1.11.x of the adapter is compatible with dbt-core 1.11.x.
+
+## Supported Python versions
+
+The adapter is tested against:
+
+| Python version | Status |
+|---|---|
+| 3.10 | Installable (not tested in CI) |
+| 3.11 | Officially supported |
+| 3.12 | Officially supported |
+| 3.13 | Officially supported |
 
 ## Supported SQL Server versions
 
@@ -79,6 +92,7 @@ Latest pre-release: ![GitHub tag (latest SemVer pre-release)](https://img.shield
 |---|---|---|
 | `pyodbc` | `dbt-sqlserver[pyodbc]` or `pyodbc` | `unixodbc-dev` plus the Microsoft ODBC Driver for SQL Server |
 | `mssql-python` | `dbt-sqlserver[mssql]` or `mssql-python` | `libltdl7`, `libkrb5-3`, `libgssapi-krb5-2` |
+| `adbc` *(experimental)* | `dbt-sqlserver[adbc]` | none (driver binary installed separately via the `dbc` CLI) |
 
 
 ### `pyodbc` backend
@@ -143,6 +157,16 @@ your_profile:
       backend: mssql-python  # <-- enables this backend
 ```
 
+### `adbc` backend *(experimental)*
+
+An Arrow-native backend built on [ADBC](https://arrow.apache.org/adbc/), avoiding the row-based ODBC/DB-API bridge entirely. SQL Server authentication only (no Azure AD / Windows auth yet).
+
+```shell
+pip install -U "dbt-sqlserver[adbc]"
+```
+
+The driver binary is not on PyPI and must be installed once via the `dbc` CLI. See [docs/adbc_backend.md](docs/adbc_backend.md) for the full setup, configuration, and known-differences guide.
+
 ## Changelog
 
 See [the changelog](CHANGELOG.md)
@@ -176,7 +200,7 @@ The same setting is also honoured via `vars:` for backwards compatibility; the b
 
 ### `backend`
 
-*(default: `pyodbc`)* Set to `mssql-python` in a profile target to use the `mssql-python` backend instead of `pyodbc`. The adapter fails if the required backend package (Python dependency), such as `pyodbc` or `mssql-python`, is not installed.
+*(default: `pyodbc`)* Set to `mssql-python` or `adbc` (experimental, see [docs/adbc_backend.md](docs/adbc_backend.md)) in a profile target to use that backend instead of `pyodbc`. The adapter fails if the required backend package (Python dependency), such as `pyodbc`, `mssql-python`, or `adbc-driver-manager`, is not installed.
 
 ### `dbt_sqlserver_enable_safe_type_expansion`
 

{dbt_sqlserver-1.11.0rc1 → dbt_sqlserver-1.12.0rc2}/README.md

@@ -2,8 +2,19 @@
 
 [dbt](https://www.getdbt.com) adapter for Microsoft SQL Server and Azure SQL services.
 
-The adapter supports dbt-core 1.10 or newer and follows the same versioning scheme.
-E.g. version 1.10.x of the adapter is compatible with dbt-core 1.10.x.
+The adapter supports dbt-core 1.11 or newer and follows the same versioning scheme.
+E.g. version 1.11.x of the adapter is compatible with dbt-core 1.11.x.
+
+## Supported Python versions
+
+The adapter is tested against:
+
+| Python version | Status |
+|---|---|
+| 3.10 | Installable (not tested in CI) |
+| 3.11 | Officially supported |
+| 3.12 | Officially supported |
+| 3.13 | Officially supported |
 
 ## Supported SQL Server versions
 
@@ -43,6 +54,7 @@ Latest pre-release: ![GitHub tag (latest SemVer pre-release)](https://img.shield
 |---|---|---|
 | `pyodbc` | `dbt-sqlserver[pyodbc]` or `pyodbc` | `unixodbc-dev` plus the Microsoft ODBC Driver for SQL Server |
 | `mssql-python` | `dbt-sqlserver[mssql]` or `mssql-python` | `libltdl7`, `libkrb5-3`, `libgssapi-krb5-2` |
+| `adbc` *(experimental)* | `dbt-sqlserver[adbc]` | none (driver binary installed separately via the `dbc` CLI) |
 
 
 ### `pyodbc` backend
@@ -107,6 +119,16 @@ your_profile:
       backend: mssql-python  # <-- enables this backend
 ```
 
+### `adbc` backend *(experimental)*
+
+An Arrow-native backend built on [ADBC](https://arrow.apache.org/adbc/), avoiding the row-based ODBC/DB-API bridge entirely. SQL Server authentication only (no Azure AD / Windows auth yet).
+
+```shell
+pip install -U "dbt-sqlserver[adbc]"
+```
+
+The driver binary is not on PyPI and must be installed once via the `dbc` CLI. See [docs/adbc_backend.md](docs/adbc_backend.md) for the full setup, configuration, and known-differences guide.
+
 ## Changelog
 
 See [the changelog](CHANGELOG.md)
@@ -140,7 +162,7 @@ The same setting is also honoured via `vars:` for backwards compatibility; the b
 
 ### `backend`
 
-*(default: `pyodbc`)* Set to `mssql-python` in a profile target to use the `mssql-python` backend instead of `pyodbc`. The adapter fails if the required backend package (Python dependency), such as `pyodbc` or `mssql-python`, is not installed.
+*(default: `pyodbc`)* Set to `mssql-python` or `adbc` (experimental, see [docs/adbc_backend.md](docs/adbc_backend.md)) in a profile target to use that backend instead of `pyodbc`. The adapter fails if the required backend package (Python dependency), such as `pyodbc`, `mssql-python`, or `adbc-driver-manager`, is not installed.
 
 ### `dbt_sqlserver_enable_safe_type_expansion`
 

dbt_sqlserver-1.12.0rc2/dbt/adapters/sqlserver/__version__.py

@@ -0,0 +1 @@
+version = "1.12.0rc2"

{dbt_sqlserver-1.11.0rc1 → dbt_sqlserver-1.12.0rc2}/dbt/adapters/sqlserver/sqlserver_adapter.py

@@ -1,4 +1,5 @@
-from typing import Any, Dict, List, Optional
+import datetime as _dt
+from typing import Any, Dict, List, Optional, Tuple, Union
 
 import agate
 import dbt_common.exceptions
@@ -37,6 +38,44 @@ from dbt.adapters.sqlserver.sqlserver_relation import SQLServerRelation
 logger = AdapterLogger("SQLServer")
 
 
+def _normalize_result_datetimes(
+    result: Union[Tuple, List[Tuple], None],
+) -> Union[Tuple, List[Tuple], None]:
+    """Strip spurious ``tzinfo=UTC`` that ADBC attaches to SQL Server
+    DATETIME2 / DATETIME values.
+
+    SQL Server does **not** store timezone offsets for these types, so the
+    correct Python representation is a naive ``datetime``.  ADBC's Arrow
+    backend wraps every ``timestamp`` column as ``timestamp[us, tz=UTC]``
+    regardless of the source semantics, producing ``datetime(…, tzinfo=UTC)``.
+    We revert that to match SQL Server semantics and to stay compatible with
+    the existing pyodbc / mssql-python backends.
+    """
+    if result is None:
+        return None
+
+    if isinstance(result, tuple):
+        return tuple(
+            (v.replace(tzinfo=None) if isinstance(v, _dt.datetime) and v.tzinfo is not None else v)
+            for v in result
+        )
+
+    if isinstance(result, list):
+        return [
+            tuple(
+                (
+                    v.replace(tzinfo=None)
+                    if isinstance(v, _dt.datetime) and v.tzinfo is not None
+                    else v
+                )
+                for v in row
+            )
+            for row in result
+        ]
+
+    return result
+
+
 class SQLServerAdapter(SQLAdapter):
     """
     Controls actual implementation of adapter, and ability to override certain methods.
@@ -77,14 +116,6 @@ class SQLServerAdapter(SQLAdapter):
     @property
     def _behavior_flags(self) -> List[BehaviorFlag]:
         return [
-            {
-                "name": "empty",
-                "default": False,
-                "description": (
-                    "When enabled, table and view materializations will be created as empty "
-                    "structures (no data)."
-                ),
-            },
             {
                 "name": "dbt_sqlserver_use_default_schema_concat",
                 "default": False,
@@ -108,13 +139,14 @@ class SQLServerAdapter(SQLAdapter):
             },
             {
                 "name": "dbt_sqlserver_use_native_string_types",
-                "default": False,
+                "default": True,
                 "description": (
-                    "When True, uses SQL Server-native string type mappings: "
+                    "When True (default), uses SQL Server-native string type mappings: "
                     "STRING -> VARCHAR(MAX), NCHAR -> NCHAR(1), NVARCHAR -> NVARCHAR(4000). "
-                    "When False (default), preserves legacy mappings: "
+                    "When False, preserves deprecated legacy mappings: "
                     "STRING and NVARCHAR -> VARCHAR(8000), NCHAR -> CHAR(1). "
-                    "The new behaviour is intended to become the default in a future release."
+                    "The legacy False behavior is deprecated "
+                    "and will be removed in a future release."
                 ),
             },
             {
@@ -129,14 +161,15 @@ class SQLServerAdapter(SQLAdapter):
             },
             {
                 "name": "dbt_sqlserver_use_dbt_transactions",
-                "default": False,
+                "default": True,
                 "description": (
-                    "When True, dbt transaction hooks (begin/commit) emit real T-SQL "
+                    "When True (default), dbt transaction hooks (begin/commit) emit real T-SQL "
                     "BEGIN TRANSACTION / COMMIT TRANSACTION statements. "
-                    "When False (default and legacy), begin/commit are no-ops and each statement "
-                    "is auto-committed by the driver. This means earlier successful statements "
+                    "When False, begin/commit are no-ops and each statement "
+                    "is auto-committed by the driver, meaning earlier successful statements "
                     "are not rolled back if a later statement fails. "
-                    "This behavior is intended to become the default in a future release."
+                    "The legacy False behavior is deprecated "
+                    "and will be removed in a future release."
                 ),
             },
         ]
@@ -155,6 +188,22 @@ class SQLServerAdapter(SQLAdapter):
         ]
         return columns
 
+    @classmethod
+    def quote(cls, identifier: str) -> str:
+        """Double-quote an identifier, doubling any embedded double quote.
+
+        ``SQLAdapter.quote`` interpolates the identifier verbatim, so a name
+        containing a ``"`` would close the quoted identifier early and the
+        remainder would parse as SQL. T-SQL escapes a delimiter by doubling
+        it -- the same rule ``QUOTENAME()`` applies to brackets -- so
+        ``ab"cd`` must render as ``"ab""cd"``.
+
+        This is the quoting used by every macro that formats an identifier
+        (see #785). Relation rendering escapes nothing, since it goes through
+        ``BaseRelation.quote_character`` upstream rather than this method.
+        """
+        return '"{}"'.format(str(identifier).replace('"', '""'))
+
     @classmethod
     def convert_boolean_type(cls, agate_table, col_idx):
         return "bit"
@@ -273,9 +322,9 @@ class SQLServerAdapter(SQLAdapter):
             if not fetch:
                 conn.handle.commit()
             if fetch == "one":
-                return cursor.fetchone()
+                return _normalize_result_datetimes(cursor.fetchone())
             elif fetch == "all":
-                return cursor.fetchall()
+                return _normalize_result_datetimes(cursor.fetchall())
             else:
                 return
         except BaseException:
@@ -427,6 +476,57 @@ class SQLServerAdapter(SQLAdapter):
     def parse_index(self, raw_index: Any) -> Optional[SQLServerIndexConfig]:
         return SQLServerIndexConfig.parse(raw_index)
 
+    @available
+    def index_needs_own_batch(self, raw_index: Any) -> bool:
+        """True when raw_index's build_options (ONLINE / RESUMABLE) force its
+        CREATE INDEX to run outside any transaction: SQL Server rejects
+        RESUMABLE inside a user transaction (error 574), and an ONLINE build
+        wrapped in one holds its locks until commit, negating the point."""
+        parsed = self.parse_index(raw_index)
+        if not parsed:
+            return False
+        return create_needs_own_batch(parsed.build_options)
+
+    @available
+    def commit_if_open(self) -> None:
+        """Commit the current transaction if one is open - a no-op otherwise.
+
+        dbt_sqlserver_use_dbt_transactions on (default) wraps a
+        materialization's whole build, from its first statement through its
+        own trailing ``adapter.commit()``, in one continuous ambient
+        transaction. Some statements must not share that transaction with
+        whatever runs after them: an ONLINE/RESUMABLE index build (SQL Server
+        rejects RESUMABLE inside a user transaction outright, and ONLINE
+        holds its locks until commit either way), or a full-refresh-in-
+        progress marker, which exists specifically to survive a later
+        failure and so must not roll back with it. This makes the prior
+        statement durable on its own; pair with begin_if_closed once the
+        statement(s) that must run outside a transaction are done, to leave
+        later code (more such statements, or the materialization's own
+        trailing ``adapter.commit()``, which raises if it finds nothing open)
+        working as if this call had never happened.
+
+        A no-op when no transaction is open: the caller's statement already
+        ran autocommitted on its own (e.g. via ``run_query``'s
+        ``auto_begin=false``, before anything else began one), so there is
+        nothing to flush. Also a no-op, at the SQL level, whenever
+        dbt_sqlserver_use_dbt_transactions is off: begin/commit still flip
+        dbt-core's bookkeeping (see
+        SQLServerConnectionManager.add_begin_query/add_commit_query), but
+        emit no real T-SQL, matching the driver's own autocommit.
+        """
+        connection = self.connections.get_thread_connection()
+        if connection is not None and connection.transaction_open:
+            self.connections.commit()
+
+    @available
+    def begin_if_closed(self) -> None:
+        """Begin a transaction if none is open - a no-op otherwise. See
+        commit_if_open, which this pairs with."""
+        connection = self.connections.get_thread_connection()
+        if connection is not None and not connection.transaction_open:
+            self.connections.begin()
+
     @available
     def validate_indexes(
         self, raw_indexes: Any, as_columnstore: Any = False, drop_unmanaged: Any = False

{dbt_sqlserver-1.11.0rc1 → dbt_sqlserver-1.12.0rc2}/dbt/adapters/sqlserver/sqlserver_auth.py

@@ -43,6 +43,14 @@ def is_mssql_python_backend(backend: "SQLServerBackend") -> bool:
     return backend.value == SQLSERVER_BACKEND_MSSQL_PYTHON
 
 
+def is_adbc_backend(backend: "SQLServerBackend") -> bool:
+    """Return whether the coerced backend enum targets ``adbc``."""
+
+    from dbt.adapters.sqlserver.sqlserver_credentials import SQLServerBackend
+
+    return backend == SQLServerBackend.adbc
+
+
 def normalize_authentication_key(value: Optional[str]) -> str:
     """Normalize a SQL Server auth or lookup key for cross-layer comparisons."""
 

{dbt_sqlserver-1.11.0rc1 → dbt_sqlserver-1.12.0rc2}/dbt/adapters/sqlserver/sqlserver_backend.py

@@ -8,6 +8,7 @@ lives in ``sqlserver_runtime.py`` and is orchestrated by
 
 from __future__ import annotations
 
+import urllib.parse
 from contextlib import suppress
 from typing import Any, Callable, Tuple
 
@@ -42,6 +43,7 @@ from dbt.adapters.sqlserver.sqlserver_runtime import (
     _RUNTIME_STATE,
     MssqlPythonModuleProtocol,
     PyodbcModuleProtocol,
+    _get_adbc,
 )
 
 logger = AdapterLogger("sqlserver")
@@ -259,12 +261,19 @@ def log_connection_string(connection_string: str) -> None:
 
 
 def is_pyodbc_handle(handle: Any) -> bool:
-    """Detect a pyodbc handle without importing pyodbc from the caller."""
+    """Detect a pyodbc handle without importing pyodbc from the caller.
+
+    ADBC handles (from ``adbc_driver_manager``) must always return False,
+    even when the handle is a mock in test code.
+    """
 
     handle_type = type(handle)
     module_name = getattr(handle_type, "__module__", "") or ""
     class_name = getattr(handle_type, "__name__", "") or ""
 
+    if "adbc" in module_name.lower() or "adbc" in class_name.lower():
+        return False
+
     if "pyodbc" in module_name or "pyodbc" in class_name:
         return True
 
@@ -340,3 +349,88 @@ def _connect_pyodbc(
         timeout=credentials.login_timeout,
     )
     return _finalize_connection_handle(handle, credentials)
+
+
+def _sanitize_adbc_uri_for_logging(uri: str) -> str:
+    """Redact the password component of an ADBC URI for safe logging."""
+    parsed = urllib.parse.urlparse(uri)
+    if parsed.password:
+        safe_netloc = parsed.netloc.replace(
+            f":{parsed.password}@",
+            ":***@",
+        )
+        sanitized = parsed._replace(netloc=safe_netloc).geturl()
+        return sanitized
+    return uri
+
+
+def build_adbc_connection_uri(credentials: SQLServerCredentials) -> str:
+    """Build a go-mssqldb URI for the ADBC backend.
+
+    Constructs URIs in the format:
+      ``sqlserver://[user:password@]host[:port]?query_params``
+
+    - User and password are URL-encoded so special characters (``@``, ``:``,
+      ``/``, etc.) are escaped per RFC 3986.
+    - Named instances (host containing ``\\``) omit the port.
+    - Query parameters: ``database``, ``encrypt``, ``TrustServerCertificate``,
+      and optional ``connection timeout``.
+    """
+
+    host = (credentials.host or "").strip()
+    port = credentials.port or 1433
+    database = credentials.database or ""
+    uid = credentials.UID or ""
+    pwd = credentials.PWD or ""
+
+    userinfo = f"{urllib.parse.quote(uid, safe='')}:{urllib.parse.quote(pwd, safe='')}"
+
+    if "\\" in host:
+        authority = f"{userinfo}@{host}"
+    else:
+        authority = f"{userinfo}@{host}:{port}"
+
+    query_parts = [
+        f"database={urllib.parse.quote(database, safe='')}",
+        f"encrypt={str(credentials.encrypt).lower()}",
+        f"TrustServerCertificate={str(credentials.trust_cert).lower()}",
+    ]
+
+    if credentials.login_timeout and credentials.login_timeout > 0:
+        query_parts.append(f"connection timeout={credentials.login_timeout}")
+
+    query_string = "&".join(query_parts)
+    return f"sqlserver://{authority}?{query_string}"
+
+
+def _connect_adbc(credentials: SQLServerCredentials, uri: str) -> Any:
+    """Open an ADBC connection using the constructed go-mssqldb URI.
+
+    The ADBC mssql driver (``"mssql"``) is the only supported driver.
+    Connections are opened with ``autocommit=True`` so that DDL statements
+    (``CREATE SCHEMA``, ``CREATE TABLE``, …) auto-commit without extra
+    round-trips.  When ``dbt_sqlserver_use_dbt_transactions: true``, dbt
+    emits explicit ``BEGIN TRANSACTION`` / ``COMMIT TRANSACTION`` SQL
+    that correctly nests on top of the autocommit session -- exactly the
+    same strategy used by the pyodbc backend.
+    """
+
+    sanitized = _sanitize_adbc_uri_for_logging(uri)
+    logger.debug(f"Connecting to SQL Server with ADBC: {sanitized}")
+
+    adbc_module = _get_adbc()
+    return adbc_module.connect(
+        driver="mssql",
+        db_kwargs={"uri": uri},
+        autocommit=True,
+    )
+
+
+def get_adbc_retryable_exceptions() -> Tuple[type[Exception], ...]:
+    """Return the ADBC exception types that the connection manager may retry."""
+
+    adbc_module = _get_adbc()
+    return (
+        adbc_module.InternalError,
+        adbc_module.OperationalError,
+    )