dbt-sqlserver 1.12.0rc4__tar.gz → 1.12.2__tar.gz

{dbt_sqlserver-1.12.0rc4 → dbt_sqlserver-1.12.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dbt-sqlserver
-Version: 1.12.0rc4
+Version: 1.12.2
 Summary: A Microsoft SQL Server adapter plugin for dbt
 Author: Mikael Ene, Anders Swanson, Sam Debruyn, Cor Zuurmond, Cody Scott
 License: MIT
@@ -77,7 +77,7 @@ We've bundled all documentation on the dbt docs site:
 - [Profile setup & authentication](https://docs.getdbt.com/reference/warehouse-profiles/mssql-profile)
 - [Adapter documentation, usage and important notes](https://docs.getdbt.com/reference/resource-configs/mssql-configs)
 
-Join us on the [dbt Slack](https://getdbt.slack.com/archives/CMRMDDQ9W) to ask questions, get help, or to discuss the project.
+Ask questions and get help in [GitHub Discussions](https://github.com/dbt-msft/dbt-sqlserver/discussions/categories/q-a). The [dbt Slack](https://getdbt.slack.com/archives/CMRMDDQ9W) channel is there for chatting with the community.
 
 ## Installation
 
@@ -166,11 +166,11 @@ An Arrow-native backend built on [ADBC](https://arrow.apache.org/adbc/), avoidin
 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.
+The driver binary is not on PyPI and must be installed once via the `dbc` CLI. See [docs/adbc_backend.md](https://github.com/dbt-msft/dbt-sqlserver/blob/master/docs/adbc_backend.md) for the full setup, configuration, and known-differences guide.
 
 ## Changelog
 
-See [the changelog](CHANGELOG.md)
+See [the changelog](https://github.com/dbt-msft/dbt-sqlserver/blob/master/CHANGELOG.md)
 
 ## Configuration
 
@@ -201,7 +201,7 @@ The same setting is also honoured via `vars:` for backwards compatibility; the b
 
 ### `backend`
 
-*(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.
+*(default: `pyodbc`)* Set to `mssql-python` or `adbc` (experimental, see [docs/adbc_backend.md](https://github.com/dbt-msft/dbt-sqlserver/blob/master/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`
 
@@ -227,7 +227,7 @@ two paths that commit a full-refresh marker before the load
 existing table), where neither scope can roll it back. `build` stages
 it inside the hook's transaction, for the one case `load` cannot serve: a
 `transaction: true` pre-hook that creates an object the model reads. See
-[docs/transaction_scope.md](docs/transaction_scope.md) for the full flow and
+[docs/transaction_scope.md](https://github.com/dbt-msft/dbt-sqlserver/blob/master/docs/transaction_scope.md) for the full flow and
 the post-hook ordering change.
 
 ### `dbt_sqlserver_use_dbt_transactions`
@@ -240,11 +240,12 @@ The driver connection remains in autocommit mode (`autocommit=true`) in both mod
 
 This is now the default and should be tested carefully with project-specific materializations and hooks. Projects that depend on autocommit-only behavior should set the flag to `false` during migration.
 
+**Compatibility notes:** Enabling `dbt_sqlserver_use_dbt_transactions: true` may expose transaction-state assumptions hidden by autocommit-only mode. Explicit transaction macros may interact with dbt-managed transactions, and cleanup after failed DDL/DML may differ. Review pre/post hooks for in-transaction vs out-of-transaction semantics.
+
 ```yaml
 # dbt_project.yml
 flags:
-  dbt_sqlserver_enable_safe_type_expansion: true
-  dbt_sqlserver_use_dbt_transactions: true # default
+  dbt_sqlserver_use_dbt_transactions: false # legacy autocommit; deprecated
 ```
 
 ### `dbt_sqlserver_use_native_string_types`
@@ -287,7 +288,11 @@ your_profile:
 
 ### `prefer_single_alter_column`
 
-*(default: `false`)* Model-level config that controls how `alter_column_type` changes column types on tables. When `false` (default), the adapter uses the safer approach: add a temporary column, copy data, drop the original, and rename. When `true`, the adapter uses a single `ALTER COLUMN` statement, which is faster on small, medium tables and instant on safe type expansions but may fail for types that cannot be implicitly converted.
+*(default: unset)* Model-level config that controls how `alter_column_type` changes column types on tables:
+
+* `true`: a single `ALTER COLUMN` statement. It is atomic, instant for a longer `varchar`/`nvarchar`, and keeps the column's indexes, default constraint and position. It fails for types that cannot be implicitly converted, and changing `varchar` to `nvarchar` on a large clustered columnstore table can fail with Msg 35357 (dictionary size limit).
+* `false`: add a temporary column, copy the data, drop the original and rename. It fails when an index, default constraint or statistics object depends on the column, and it moves the column to the end of the table. A failed attempt no longer blocks the next run.
+* unset (default): `true` when column type expansion widens a column within its type (a longer `varchar`, or `varchar(max)`), `false` for every other change.
 
 ```sql
 -- In an incremental model
@@ -295,8 +300,6 @@ your_profile:
            prefer_single_alter_column=true) }}
 ```
 
-**Compatibility notes:** Enabling `dbt_sqlserver_use_dbt_transactions: true` may expose transaction-state assumptions hidden by autocommit-only mode. Explicit transaction macros may interact with dbt-managed transactions, and cleanup after failed DDL/DML may differ. Review pre/post hooks for in-transaction vs out-of-transaction semantics.
-
 ### `as_columnstore`
 
 *(default: `true`)* When building a table, the adapter creates a [clustered columnstore index](https://learn.microsoft.com/en-us/sql/relational-databases/indexes/columnstore-indexes-overview) (CCI) on it. Set `as_columnstore: false` to build a plain rowstore table instead.
@@ -322,6 +325,10 @@ You can also set it per model:
 
 With `table_refresh_method: dml`, a schema change makes the refresh fall back to a rename-swap. On that run — and only that run — the scratch table is rebuilt the way this adapter builds every other table, so it carries the model's columnstore index, and under an enforced contract its `NOT NULL`s and inline constraints, into the swap. That run therefore executes the model's SQL twice — once for the `SELECT … INTO` that probes for the schema change, once for the rebuild — and builds the columnstore index once. Steady-state refreshes are unaffected and keep the single `SELECT … INTO`. A table that lost its columnstore index to this bug before you upgraded is not repaired automatically: its schema still matches, so it stays on the cheap path. To rebuild it, temporarily set `full_refresh_build: prebuilt` and run with `--full-refresh`.
 
+### Ephemeral models
+
+Ephemeral models are supported, with one limit: an ephemeral model can't start with its own `WITH`. dbt inlines it as a CTE, and T-SQL can't nest a `WITH` inside one (still true on SQL Server 2025). Write it with derived tables instead, or materialize it as a `view`, which SQL Server expands into the calling query the same way.
+
 ### Constraints
 
 Constraints declared in a model's yaml are applied when — and only when — the model's [contract](https://docs.getdbt.com/reference/resource-configs/contract) is enforced, which is what every dbt adapter does and keeps their cost opt-in. (dbt-core does not raise if you declare constraints with the contract off — they are simply never emitted.) `not_null`, `check`, `unique`, `primary_key` and `foreign_key` are all supported.
@@ -334,7 +341,7 @@ A *model-level* constraint carrying `name:` is applied by `ALTER TABLE … ADD C
 
 Name a constraint when you want it stable across environments (schema-comparison tools report the generated names as differences) or need to reference it later. A `name:` on a *column-level* constraint is ignored with a warning — declare it under the model's `constraints:` key instead.
 
-The full set of rules, with the test that verifies each, is in [docs/constraints.md](docs/constraints.md).
+The full set of rules, with the test that verifies each, is in [docs/constraints.md](https://github.com/dbt-msft/dbt-sqlserver/blob/master/docs/constraints.md).
 
 ```yaml
 models:
@@ -492,8 +499,8 @@ The `denies` config re-applies object-level DENYs after each build, diffed again
 [![Integration tests on SQL Server](https://github.com/dbt-msft/dbt-sqlserver/actions/workflows/integration-tests-sqlserver.yml/badge.svg)](https://github.com/dbt-msft/dbt-sqlserver/actions/workflows/integration-tests-sqlserver.yml)
 
 This adapter is community-maintained.
-You are welcome to contribute by creating issues, opening or reviewing pull requests, or helping other users in the Slack channel.
-If you're unsure how to get started, check out our [contributing guide](CONTRIBUTING.md).
+You are welcome to contribute by creating issues, opening or reviewing pull requests, or helping other users in [Discussions](https://github.com/dbt-msft/dbt-sqlserver/discussions) and on the [dbt Slack](https://getdbt.slack.com/archives/CMRMDDQ9W).
+If you're unsure how to get started, check out our [contributing guide](https://github.com/dbt-msft/dbt-sqlserver/blob/master/CONTRIBUTING.md).
 
 ## License
 

{dbt_sqlserver-1.12.0rc4 → dbt_sqlserver-1.12.2}/README.md

@@ -39,7 +39,7 @@ We've bundled all documentation on the dbt docs site:
 - [Profile setup & authentication](https://docs.getdbt.com/reference/warehouse-profiles/mssql-profile)
 - [Adapter documentation, usage and important notes](https://docs.getdbt.com/reference/resource-configs/mssql-configs)
 
-Join us on the [dbt Slack](https://getdbt.slack.com/archives/CMRMDDQ9W) to ask questions, get help, or to discuss the project.
+Ask questions and get help in [GitHub Discussions](https://github.com/dbt-msft/dbt-sqlserver/discussions/categories/q-a). The [dbt Slack](https://getdbt.slack.com/archives/CMRMDDQ9W) channel is there for chatting with the community.
 
 ## Installation
 
@@ -128,11 +128,11 @@ An Arrow-native backend built on [ADBC](https://arrow.apache.org/adbc/), avoidin
 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.
+The driver binary is not on PyPI and must be installed once via the `dbc` CLI. See [docs/adbc_backend.md](https://github.com/dbt-msft/dbt-sqlserver/blob/master/docs/adbc_backend.md) for the full setup, configuration, and known-differences guide.
 
 ## Changelog
 
-See [the changelog](CHANGELOG.md)
+See [the changelog](https://github.com/dbt-msft/dbt-sqlserver/blob/master/CHANGELOG.md)
 
 ## Configuration
 
@@ -163,7 +163,7 @@ The same setting is also honoured via `vars:` for backwards compatibility; the b
 
 ### `backend`
 
-*(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.
+*(default: `pyodbc`)* Set to `mssql-python` or `adbc` (experimental, see [docs/adbc_backend.md](https://github.com/dbt-msft/dbt-sqlserver/blob/master/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`
 
@@ -189,7 +189,7 @@ two paths that commit a full-refresh marker before the load
 existing table), where neither scope can roll it back. `build` stages
 it inside the hook's transaction, for the one case `load` cannot serve: a
 `transaction: true` pre-hook that creates an object the model reads. See
-[docs/transaction_scope.md](docs/transaction_scope.md) for the full flow and
+[docs/transaction_scope.md](https://github.com/dbt-msft/dbt-sqlserver/blob/master/docs/transaction_scope.md) for the full flow and
 the post-hook ordering change.
 
 ### `dbt_sqlserver_use_dbt_transactions`
@@ -202,11 +202,12 @@ The driver connection remains in autocommit mode (`autocommit=true`) in both mod
 
 This is now the default and should be tested carefully with project-specific materializations and hooks. Projects that depend on autocommit-only behavior should set the flag to `false` during migration.
 
+**Compatibility notes:** Enabling `dbt_sqlserver_use_dbt_transactions: true` may expose transaction-state assumptions hidden by autocommit-only mode. Explicit transaction macros may interact with dbt-managed transactions, and cleanup after failed DDL/DML may differ. Review pre/post hooks for in-transaction vs out-of-transaction semantics.
+
 ```yaml
 # dbt_project.yml
 flags:
-  dbt_sqlserver_enable_safe_type_expansion: true
-  dbt_sqlserver_use_dbt_transactions: true # default
+  dbt_sqlserver_use_dbt_transactions: false # legacy autocommit; deprecated
 ```
 
 ### `dbt_sqlserver_use_native_string_types`
@@ -249,7 +250,11 @@ your_profile:
 
 ### `prefer_single_alter_column`
 
-*(default: `false`)* Model-level config that controls how `alter_column_type` changes column types on tables. When `false` (default), the adapter uses the safer approach: add a temporary column, copy data, drop the original, and rename. When `true`, the adapter uses a single `ALTER COLUMN` statement, which is faster on small, medium tables and instant on safe type expansions but may fail for types that cannot be implicitly converted.
+*(default: unset)* Model-level config that controls how `alter_column_type` changes column types on tables:
+
+* `true`: a single `ALTER COLUMN` statement. It is atomic, instant for a longer `varchar`/`nvarchar`, and keeps the column's indexes, default constraint and position. It fails for types that cannot be implicitly converted, and changing `varchar` to `nvarchar` on a large clustered columnstore table can fail with Msg 35357 (dictionary size limit).
+* `false`: add a temporary column, copy the data, drop the original and rename. It fails when an index, default constraint or statistics object depends on the column, and it moves the column to the end of the table. A failed attempt no longer blocks the next run.
+* unset (default): `true` when column type expansion widens a column within its type (a longer `varchar`, or `varchar(max)`), `false` for every other change.
 
 ```sql
 -- In an incremental model
@@ -257,8 +262,6 @@ your_profile:
            prefer_single_alter_column=true) }}
 ```
 
-**Compatibility notes:** Enabling `dbt_sqlserver_use_dbt_transactions: true` may expose transaction-state assumptions hidden by autocommit-only mode. Explicit transaction macros may interact with dbt-managed transactions, and cleanup after failed DDL/DML may differ. Review pre/post hooks for in-transaction vs out-of-transaction semantics.
-
 ### `as_columnstore`
 
 *(default: `true`)* When building a table, the adapter creates a [clustered columnstore index](https://learn.microsoft.com/en-us/sql/relational-databases/indexes/columnstore-indexes-overview) (CCI) on it. Set `as_columnstore: false` to build a plain rowstore table instead.
@@ -284,6 +287,10 @@ You can also set it per model:
 
 With `table_refresh_method: dml`, a schema change makes the refresh fall back to a rename-swap. On that run — and only that run — the scratch table is rebuilt the way this adapter builds every other table, so it carries the model's columnstore index, and under an enforced contract its `NOT NULL`s and inline constraints, into the swap. That run therefore executes the model's SQL twice — once for the `SELECT … INTO` that probes for the schema change, once for the rebuild — and builds the columnstore index once. Steady-state refreshes are unaffected and keep the single `SELECT … INTO`. A table that lost its columnstore index to this bug before you upgraded is not repaired automatically: its schema still matches, so it stays on the cheap path. To rebuild it, temporarily set `full_refresh_build: prebuilt` and run with `--full-refresh`.
 
+### Ephemeral models
+
+Ephemeral models are supported, with one limit: an ephemeral model can't start with its own `WITH`. dbt inlines it as a CTE, and T-SQL can't nest a `WITH` inside one (still true on SQL Server 2025). Write it with derived tables instead, or materialize it as a `view`, which SQL Server expands into the calling query the same way.
+
 ### Constraints
 
 Constraints declared in a model's yaml are applied when — and only when — the model's [contract](https://docs.getdbt.com/reference/resource-configs/contract) is enforced, which is what every dbt adapter does and keeps their cost opt-in. (dbt-core does not raise if you declare constraints with the contract off — they are simply never emitted.) `not_null`, `check`, `unique`, `primary_key` and `foreign_key` are all supported.
@@ -296,7 +303,7 @@ A *model-level* constraint carrying `name:` is applied by `ALTER TABLE … ADD C
 
 Name a constraint when you want it stable across environments (schema-comparison tools report the generated names as differences) or need to reference it later. A `name:` on a *column-level* constraint is ignored with a warning — declare it under the model's `constraints:` key instead.
 
-The full set of rules, with the test that verifies each, is in [docs/constraints.md](docs/constraints.md).
+The full set of rules, with the test that verifies each, is in [docs/constraints.md](https://github.com/dbt-msft/dbt-sqlserver/blob/master/docs/constraints.md).
 
 ```yaml
 models:
@@ -454,8 +461,8 @@ The `denies` config re-applies object-level DENYs after each build, diffed again
 [![Integration tests on SQL Server](https://github.com/dbt-msft/dbt-sqlserver/actions/workflows/integration-tests-sqlserver.yml/badge.svg)](https://github.com/dbt-msft/dbt-sqlserver/actions/workflows/integration-tests-sqlserver.yml)
 
 This adapter is community-maintained.
-You are welcome to contribute by creating issues, opening or reviewing pull requests, or helping other users in the Slack channel.
-If you're unsure how to get started, check out our [contributing guide](CONTRIBUTING.md).
+You are welcome to contribute by creating issues, opening or reviewing pull requests, or helping other users in [Discussions](https://github.com/dbt-msft/dbt-sqlserver/discussions) and on the [dbt Slack](https://getdbt.slack.com/archives/CMRMDDQ9W).
+If you're unsure how to get started, check out our [contributing guide](https://github.com/dbt-msft/dbt-sqlserver/blob/master/CONTRIBUTING.md).
 
 ## License
 

dbt_sqlserver-1.12.2/dbt/adapters/sqlserver/__version__.py

@@ -0,0 +1 @@
+version = "1.12.2"

{dbt_sqlserver-1.12.0rc4 → dbt_sqlserver-1.12.2}/dbt/adapters/sqlserver/sqlserver_adapter.py

@@ -1,6 +1,7 @@
 import datetime as _dt
 import re
-from typing import Any, Dict, List, Optional, Tuple, Type, Union
+from contextlib import contextmanager
+from typing import Any, Dict, Iterator, List, Optional, Tuple, Type, Union
 
 import agate
 import dbt_common.exceptions
@@ -446,8 +447,15 @@ class SQLServerAdapter(SQLAdapter):
 
     @classmethod
     def convert_number_type(cls, agate_table, col_idx):
-        decimals = agate_table.aggregate(agate.MaxPrecision(col_idx))
-        return "float" if decimals else "int"
+        if agate_table.aggregate(agate.MaxPrecision(col_idx)):
+            return "float"
+        values = agate_table.columns[col_idx].values_without_nulls()
+        low, high = (min(values), max(values)) if values else (0, 0)
+        if -(2**31) <= low and high < 2**31:
+            return "int"
+        if -(2**63) <= low and high < 2**63:
+            return "bigint"
+        return "numeric(38,0)"
 
     def create_schema(self, relation: BaseRelation) -> None:
         relation = relation.without_identifier()
@@ -470,6 +478,8 @@ class SQLServerAdapter(SQLAdapter):
         # see https://github.com/fishtown-analytics/dbt/pull/2255
         lens = [len(d.encode("utf-8")) for d in column.values_without_nulls()]
         max_len = max(lens) if lens else 64
+        if max_len > 8000:
+            return "varchar(max)"
         length = max_len if max_len > 16 else 16
         return "varchar({})".format(length)
 
@@ -828,13 +838,27 @@ class SQLServerAdapter(SQLAdapter):
 
         return True
 
-    def expand_column_types(self, goal, current, max_rows: int = 1000000):
+    def expand_column_types(
+        self,
+        goal,
+        current,
+        max_rows: int = 1000000,
+        prefer_single_alter_column: Optional[bool] = None,
+    ):
         """Widen ``current``'s columns to match ``goal``, preserving the
         nvarchar / nchar family.
 
         Same-family resizes (a longer varchar) always proceed. Cross-family
         promotions (varchar -> nvarchar) are opt-in and gated; see
         ``_safe_expansion_allowed``.
+
+        ``prefer_single_alter_column`` is the model's config. Unset, a
+        same-family resize uses a single ``ALTER COLUMN``: metadata-only for a
+        longer varchar, atomic, and it keeps indexes, defaults and column
+        position, all of which block or move the four-step rewrite. A
+        cross-family promotion keeps the four-step path, since a single
+        ``ALTER COLUMN`` to nvarchar on a large columnstore table can fail
+        with Msg 35357 (dictionary size limit).
         """
 
         reference_columns = {c.name: c for c in self.get_columns_in_relation(goal)}
@@ -847,8 +871,9 @@ class SQLServerAdapter(SQLAdapter):
             if target_column is None:
                 continue
 
+            same_family = target_column.can_expand_to(reference_column)
             if not (
-                target_column.can_expand_to(reference_column)
+                same_family
                 or (safe_expansion_allowed and target_column.can_expand_safe(reference_column))
             ):
                 continue
@@ -865,11 +890,46 @@ class SQLServerAdapter(SQLAdapter):
                     table=_make_ref_key_dict(current),
                 )
             )
-            self.alter_column_type(current, column_name, new_type)
+            prefer_single = (
+                same_family if prefer_single_alter_column is None else prefer_single_alter_column
+            )
+            self.alter_column_type(current, column_name, new_type, prefer_single)
+
+    def alter_column_type(
+        self,
+        relation,
+        column_name,
+        new_column_type,
+        prefer_single_alter_column: Optional[bool] = None,
+    ) -> None:
+        """Pass the model's ``prefer_single_alter_column`` to the macro.
+
+        A macro run from Python sees no model config, so
+        ``config.get('prefer_single_alter_column')`` inside it is always the
+        default; and dbt-adapters' ``alter_column_type`` dispatcher forwards
+        only the three standard arguments. When the setting is known, call
+        the SQL Server implementation with it directly (dbt-msft/dbt-sqlserver#836).
+        """
+        if prefer_single_alter_column is None:
+            super().alter_column_type(relation, column_name, new_column_type)
+            return
+        self.execute_macro(
+            "sqlserver__alter_column_type",
+            kwargs={
+                "relation": relation,
+                "column_name": column_name,
+                "new_column_type": new_column_type,
+                "prefer_single": prefer_single_alter_column,
+            },
+        )
 
     @available.parse_none
     def expand_target_column_types(
-        self, from_relation: BaseRelation, to_relation: BaseRelation, max_rows: int = 1000000
+        self,
+        from_relation: BaseRelation,
+        to_relation: BaseRelation,
+        max_rows: int = 1000000,
+        prefer_single_alter_column: Optional[bool] = None,
     ) -> None:
         if not isinstance(from_relation, self.Relation):
             from dbt.adapters.base.impl import MacroArgTypeError
@@ -889,7 +949,7 @@ class SQLServerAdapter(SQLAdapter):
                 got_value=to_relation,
                 expected_type=self.Relation,
             )
-        self.expand_column_types(from_relation, to_relation, max_rows)
+        self.expand_column_types(from_relation, to_relation, max_rows, prefer_single_alter_column)
 
     @available
     def parse_index(self, raw_index: Any) -> Optional[SQLServerIndexConfig]:
@@ -906,6 +966,28 @@ class SQLServerAdapter(SQLAdapter):
             return False
         return create_needs_own_batch(parsed.build_options)
 
+    # dbt-core's run-operation runs on connections with these names.
+    _RUN_OPERATION_CONNECTION_PREFIXES = ("macro_", "inline_query")
+
+    @contextmanager
+    def connection_named(
+        self, name: str, query_header_context: Any = None, should_release_connection: bool = True
+    ) -> Iterator[None]:
+        """Commit a run-operation's open transaction when it finishes cleanly.
+
+        Stopgap for dbt-labs/dbt#16434, remove once dbt-core commits after a
+        run-operation: dbt-core never does, so with dbt-managed transactions
+        on, a write through ``statement()`` (auto_begin) is rolled back when
+        the connection closes. The commit sits after the ``yield`` so it runs
+        only when the macro did not raise; a failed macro still rolls back.
+        Matching on the connection name is a heuristic, since dbt-core marks
+        run-operation connections no other way.
+        """
+        with super().connection_named(name, query_header_context, should_release_connection):
+            yield
+            if name.startswith(self._RUN_OPERATION_CONNECTION_PREFIXES):
+                self.commit_if_open()
+
     @available
     def commit_if_open(self) -> None:
         """Commit the current transaction if one is open - a no-op otherwise.

{dbt_sqlserver-1.12.0rc4 → dbt_sqlserver-1.12.2}/dbt/adapters/sqlserver/sqlserver_configs.py

@@ -10,7 +10,8 @@ from dbt.adapters.sqlserver.relation_configs import SQLServerIndexConfig
 @dataclass
 class SQLServerConfigs(AdapterConfig):
     auto_provision_aad_principals: Optional[bool] = False
-    prefer_single_alter_column: Optional[bool] = False
+    # unset: single ALTER COLUMN for same-family widening, four-step otherwise
+    prefer_single_alter_column: Optional[bool] = None
     column_type_expansion_max_rows: int = 1000000
     indexes: Optional[Tuple[SQLServerIndexConfig, ...]] = None
     # false (default) | warn | true - how index reconciliation treats

{dbt_sqlserver-1.12.0rc4 → dbt_sqlserver-1.12.2}/dbt/include/sqlserver/macros/adapters/columns.sql

@@ -36,19 +36,38 @@
     {% endif %}
 {% endmacro %}
 
-{% macro sqlserver__alter_column_type(relation, column_name, new_column_type) %}
+{% macro sqlserver__alter_column_type(relation, column_name, new_column_type, prefer_single=none) %}
 
-    {% set prefer_single = config.get('prefer_single_alter_column', false) %}
+    {#-- Called from Python (expand_target_column_types) the macro sees no model config, so the adapter passes prefer_single in (dbt-msft/dbt-sqlserver#836) --#}
+    {% if prefer_single is none %}
+        {% set prefer_single = config.get('prefer_single_alter_column', false) %}
+    {% endif %}
+
+    {#-- ALTER COLUMN without NOT NULL makes the column nullable --#}
+    {% set nullable_sql %}
+        {{ get_use_database_sql(relation.database) }}
+        select columnproperty(object_id('{{ escape_single_quotes(relation) }}'), '{{ escape_single_quotes(column_name) }}', 'AllowsNull')
+    {%- endset %}
+    {%- set not_null = run_query(nullable_sql).columns[0].values()[0] == 0 -%}
 
     {% if prefer_single and relation.type == 'table' %}
         {% set alter_sql %}
             alter {{ relation.type }} {{ relation }}
-            alter column "{{ column_name }}" {{ new_column_type }};
+            alter column "{{ column_name }}" {{ new_column_type }}{{ ' not null' if not_null }};
         {%- endset %}
         {% do run_query(alter_sql) %}
 
     {% else %}
         {%- set tmp_column = column_name + "__dbt_alter" -%}
+        {%- set relation_name = escape_single_quotes(relation.include(database=False)) -%}
+
+        {#-- The four steps below autocommit one by one, so a failed run can leave tmp_column behind, and the next run's ADD then fails forever (dbt-msft/dbt-sqlserver#836).
+             Drop it first. It is only a partial copy while the original column still exists; if the original is gone, tmp_column holds the data, so it is left alone. --#}
+        {% set drop_leftover %}
+            if col_length('{{ relation_name }}', '{{ escape_single_quotes(tmp_column) }}') is not null
+                and col_length('{{ relation_name }}', '{{ escape_single_quotes(column_name) }}') is not null
+                alter {{ relation.type }} {{ relation }} drop column "{{ tmp_column }}";
+        {%- endset %}
 
         {% set add_column %}
             alter {{ relation.type }} {{ relation }}
@@ -62,13 +81,21 @@
             drop column "{{ column_name }}";
         {%- endset %}
         {% set rename_column %}
-            exec sp_rename '{{ escape_single_quotes(relation.include(database=False)) }}.{{ escape_single_quotes(adapter.quote(tmp_column)) }}', '{{ escape_single_quotes(column_name) }}', 'column'
+            exec sp_rename '{{ relation_name }}.{{ escape_single_quotes(adapter.quote(tmp_column)) }}', '{{ escape_single_quotes(column_name) }}', 'column'
+        {%- endset %}
+        {% set alter_sql_not_null %}
+            alter {{ relation.type }} {{ relation }}
+            alter column "{{ column_name }}" {{ new_column_type }} not null;
         {%- endset %}
 
+        {% do run_query(drop_leftover) %}
         {% do run_query(add_column) %}
         {% do run_query(update_column) %}
         {% do run_query(drop_column) %}
         {% do run_query(rename_column) %}
+        {% if not_null %}
+            {% do run_query(alter_sql_not_null) %}
+        {% endif %}
     {% endif %}
 
 {% endmacro %}

{dbt_sqlserver-1.12.0rc4 → dbt_sqlserver-1.12.2}/dbt/include/sqlserver/macros/adapters/metadata.sql

@@ -197,11 +197,13 @@
     - dm_exec_describe_first_result_set is referenced once: each reference compiles the body.
     - Its error row is kept, so a body it cannot describe is refreshed.
     - COLLATE DATABASE_DEFAULT, or the join fails where catalog and database collations differ.
-    - The body is inlined: the function needs nvarchar and mssql-python binds str as varchar. -#}
+    - Run through sp_executesql, so the statement text is the same for every view and SQL
+      Server caches one plan for all of them.
+    - The values are inlined, typed by the parameter list: the function needs nvarchar and
+      mssql-python binds str as varchar. -#}
 {% macro sqlserver__get_view_skip_check_sql(relation, compiled_sql) -%}
-  {%- set object_name = "quotename('" ~ relation.schema ~ "') + '.' + quotename('" ~ relation.identifier ~ "')" -%}
-  {{ get_use_database_sql(relation.database) }}
-  declare @dbt_sqlserver_skip_check_body nvarchar(max) = N'{{ escape_single_quotes(compiled_sql) }}';
+  {%- set object_name = "quotename(@schema) + '.' + quotename(@identifier)" -%}
+  {%- set check_sql -%}
   select
       object_definition(object_id({{ object_name }}, 'V')) as definition,
       case when exists (
@@ -234,6 +236,13 @@
                     <> isnull(cached.collation_name, '') collate database_default
       ) then 1 else 0 end as needs_refresh
   where object_id({{ object_name }}, 'V') is not null
+  {%- endset -%}
+  {{ get_use_database_sql(relation.database) }}
+  exec sp_executesql N'{{ escape_single_quotes(check_sql) }}',
+      N'@schema sysname, @identifier sysname, @dbt_sqlserver_skip_check_body nvarchar(max)',
+      @schema = N'{{ escape_single_quotes(relation.schema) }}',
+      @identifier = N'{{ escape_single_quotes(relation.identifier) }}',
+      @dbt_sqlserver_skip_check_body = N'{{ escape_single_quotes(compiled_sql) }}';
 {% endmacro %}
 
 {% macro sqlserver__get_relation_last_modified(information_schema, relations) -%}

{dbt_sqlserver-1.12.0rc4 → dbt_sqlserver-1.12.2}/dbt/include/sqlserver/macros/adapters/relation.sql

@@ -8,14 +8,9 @@
 
 {% macro sqlserver__get_drop_sql(relation) -%}
   {% if relation.type == 'view' -%}
-      {#- auto_begin=false, matching dbt-adapters' own relations/drop.sql: a
-          read-only lookup must not open the ambient transaction. This is the
-          first statement of the temp-relation build (create.sql ->
-          adapter.drop_relation), so with the default auto_begin=True it held
-          that build's sys.sysschobjs X locks until the materialization
-          committed, deadlocking a concurrent worker (error 1205). -#}
-      {% call statement('find_references', fetch_result=true, auto_begin=false) %}
-        {{ get_use_database_sql(relation.database) }}
+      {#- Run through sp_executesql, so the statement text is the same for every
+          relation and SQL Server caches one plan for all of them. -#}
+      {%- set find_references_sql -%}
         select
             sch.name as schema_name,
             obj.name as view_name
@@ -24,11 +19,25 @@
         on refs.referencing_id = obj.object_id
         inner join sys.schemas sch {{ information_schema_hints() }}
         on obj.schema_id = sch.schema_id
-        where refs.referenced_database_name = '{{ relation.database }}'
-        and refs.referenced_schema_name = '{{ relation.schema }}'
-        and refs.referenced_entity_name = '{{ relation.identifier }}'
+        where refs.referenced_database_name = @database
+        and refs.referenced_schema_name = @schema
+        and refs.referenced_entity_name = @identifier
         and obj.type = 'V'
         {{ get_query_options() }}
+      {%- endset %}
+      {#- auto_begin=false, matching dbt-adapters' own relations/drop.sql: a
+          read-only lookup must not open the ambient transaction. This is the
+          first statement of the temp-relation build (create.sql ->
+          adapter.drop_relation), so with the default auto_begin=True it held
+          that build's sys.sysschobjs X locks until the materialization
+          committed, deadlocking a concurrent worker (error 1205). -#}
+      {% call statement('find_references', fetch_result=true, auto_begin=false) %}
+        {{ get_use_database_sql(relation.database) }}
+        exec sp_executesql N'{{ escape_single_quotes(find_references_sql) }}',
+            N'@database sysname, @schema sysname, @identifier sysname',
+            @database = N'{{ escape_single_quotes(relation.database) }}',
+            @schema = N'{{ escape_single_quotes(relation.schema) }}',
+            @identifier = N'{{ escape_single_quotes(relation.identifier) }}';
       {% endcall %}
       {% set references = load_result('find_references')['data'] %}
       {% for reference in references -%}

{dbt_sqlserver-1.12.0rc4 → dbt_sqlserver-1.12.2}/dbt/include/sqlserver/macros/materializations/models/incremental/incremental.sql

@@ -175,7 +175,8 @@
       {% do adapter.expand_target_column_types(
                from_relation=temp_relation,
                to_relation=target_relation,
-               max_rows=expansion_max_rows) %}
+               max_rows=expansion_max_rows,
+               prefer_single_alter_column=config.get('prefer_single_alter_column')) %}
     {% endif %}
     {#-- Process schema changes. Returns dict of changes if successful. Use source columns for upserting/merging --#}
     {% set dest_columns = process_schema_changes(on_schema_change, temp_relation, existing_relation) %}

{dbt_sqlserver-1.12.0rc4 → dbt_sqlserver-1.12.2}/dbt/include/sqlserver/macros/materializations/models/incremental/merge.sql

@@ -15,13 +15,13 @@
     {% if unique_key %}
         {% if unique_key is sequence and unique_key is not string %}
             SET NOCOUNT ON;
-            delete from {{ target }}
+            delete DBT_INTERNAL_DEST from {{ target }} as DBT_INTERNAL_DEST
             where exists (
                 select null
                 from {{ source }}
                 where
                 {% for key in unique_key %}
-                    {{ source }}.{{ key }} = {{ target }}.{{ key }}
+                    {{ source }}.{{ key }} = DBT_INTERNAL_DEST.{{ key }}
                     {{ "and " if not loop.last }}
                 {% endfor %}
             )
@@ -34,7 +34,7 @@
             SET NOCOUNT OFF;
         {% else %}
             SET NOCOUNT ON;
-            delete from {{ target }}
+            delete DBT_INTERNAL_DEST from {{ target }} as DBT_INTERNAL_DEST
             where (
                 {{ unique_key }}) in (
                 select ({{ unique_key }})

{dbt_sqlserver-1.12.0rc4 → dbt_sqlserver-1.12.2}/dbt/include/sqlserver/macros/materializations/models/view/view.sql

@@ -134,7 +134,11 @@
 
   {{ adapter.commit() }}
 
-  {{ drop_relation_if_exists(backup_relation) }}
+  {#- Only the table branch above makes a backup. A view is altered in place, and a
+      drop would still query the missing backup's dependents. -#}
+  {% if existing_relation is not none and existing_relation.type != 'view' %}
+    {{ drop_relation_if_exists(backup_relation) }}
+  {% endif %}
 
   {{ run_hooks(post_hooks, inside_transaction=False) }}
 

{dbt_sqlserver-1.12.0rc4 → dbt_sqlserver-1.12.2}/dbt/include/sqlserver/macros/materializations/snapshots/helpers.sql

@@ -1,7 +1,7 @@
 {% macro sqlserver__create_columns(relation, columns) %}
   {% set column_list %}
     {% for column_entry in columns %}
-      {{column_entry.name}} {{column_entry.data_type}}{{ ", " if not loop.last }}
+      {{ adapter.quote(column_entry.name) }} {{column_entry.data_type}}{{ ", " if not loop.last }}
     {% endfor %}
   {% endset %}
 

{dbt_sqlserver-1.12.0rc4 → dbt_sqlserver-1.12.2}/dbt/include/sqlserver/macros/materializations/snapshots/snapshot.sql

@@ -115,7 +115,8 @@
     {% set expansion_max_rows = config.get('column_type_expansion_max_rows', 1000000) %}
     {% do adapter.expand_target_column_types(from_relation=staging_table,
                                              to_relation=target_relation,
-                                             max_rows=expansion_max_rows) %}
+                                             max_rows=expansion_max_rows,
+                                             prefer_single_alter_column=config.get('prefer_single_alter_column')) %}
 
     {% set remove_columns = ['dbt_change_type', 'DBT_CHANGE_TYPE', 'dbt_unique_key', 'DBT_UNIQUE_KEY'] %}
     {% if unique_key | is_list %}

dbt_sqlserver-1.12.2/dbt/include/sqlserver/macros/materializations/snapshots/strategies.sql

@@ -0,0 +1,65 @@
+{% macro sqlserver__snapshot_hash_arguments(args) %}
+    CONVERT(VARCHAR(32), HashBytes('MD5', {% for arg in args %}
+        coalesce(cast({{ arg }} as varchar(8000)), '') {% if not loop.last %} + '|' + {% endif %}
+    {% endfor %}), 2)
+{% endmacro %}
+
+
+{#
+    dbt-adapters does not dispatch "snapshot_check_all_get_existing_columns", so
+    this shadows the global project's macro; adapter package macros take
+    precedence. Keep in sync with dbt-adapters when upgrading. When upstream
+    dispatches it, delete the public wrapper and keep the sqlserver__ handler.
+
+    Change from upstream: for a check_cols list, upstream reads the columns'
+    casing from "select <check_cols> from (<sql>) subq", and T-SQL can't nest a
+    WITH in a subquery. This reads the query's columns unwrapped, as the 'all'
+    branch does, and picks check_cols from them case-insensitively.
+#}
+
+{% macro snapshot_check_all_get_existing_columns(node, target_exists, check_cols_config) -%}
+    {{ return(sqlserver__snapshot_check_all_get_existing_columns(node, target_exists, check_cols_config)) }}
+{%- endmacro %}
+
+
+{% macro sqlserver__snapshot_check_all_get_existing_columns(node, target_exists, check_cols_config) -%}
+    {%- if not target_exists -%}
+        {#-- no table yet -> return whatever the query does --#}
+        {{ return((false, query_columns)) }}
+    {%- endif -%}
+
+    {#-- handle any schema changes --#}
+    {%- set target_relation = adapter.get_relation(database=node.database, schema=node.schema, identifier=node.alias) -%}
+
+    {% if check_cols_config == 'all' %}
+        {%- set query_columns = get_columns_in_query(node['compiled_code']) -%}
+
+    {% elif check_cols_config is iterable and (check_cols_config | length) > 0 %}
+        {%- set all_columns = get_columns_in_query(node['compiled_code']) -%}
+        {%- set all_columns_lower = all_columns | map('lower') | list -%}
+        {%- set query_columns = [] -%}
+        {%- for check_col in check_cols_config -%}
+            {%- if (check_col | lower) not in all_columns_lower -%}
+                {% do exceptions.raise_compiler_error("check_cols column '" ~ check_col ~ "' is not in the snapshot query") %}
+            {%- endif -%}
+            {%- do query_columns.append(all_columns[all_columns_lower.index(check_col | lower)]) -%}
+        {%- endfor -%}
+
+    {% else %}
+        {% do exceptions.raise_compiler_error("Invalid value for 'check_cols': " ~ check_cols_config) %}
+    {% endif %}
+
+    {%- set existing_cols = adapter.get_columns_in_relation(target_relation) | map(attribute = 'name') | list -%}
+    {%- set ns = namespace() -%} {#-- handle for-loop scoping with a namespace --#}
+    {%- set ns.column_added = false -%}
+
+    {%- set intersection = [] -%}
+    {%- for col in query_columns -%}
+        {%- if col in existing_cols -%}
+            {%- do intersection.append(adapter.quote(col)) -%}
+        {%- else -%}
+            {% set ns.column_added = true %}
+        {%- endif -%}
+    {%- endfor -%}
+    {{ return((ns.column_added, intersection)) }}
+{%- endmacro %}

{dbt_sqlserver-1.12.0rc4 → dbt_sqlserver-1.12.2}/dbt/include/sqlserver/macros/materializations/unit_tests.sql

@@ -1,3 +1,13 @@
+{%- materialization unit, adapter='sqlserver' -%}
+  {#- The default drops its fixture table inside the transaction
+      statement('main') opens and never commits, so with
+      dbt_sqlserver_use_dbt_transactions on the drop rolls back
+      (dbt-labs/dbt#16499). -#}
+  {% set relations = materialization_unit_default() %}
+  {% do adapter.commit_if_open() %}
+  {{ return(relations) }}
+{%- endmaterialization -%}
+
 {% macro sqlserver__get_unit_test_sql(main_sql, expected_fixture_sql, expected_column_names) -%}
 
   {{ get_use_database_sql(target.database) }}

{dbt_sqlserver-1.12.0rc4 → dbt_sqlserver-1.12.2}/dbt/include/sqlserver/macros/relations/table/create.sql

@@ -35,7 +35,11 @@
         {{ get_assert_columns_equivalent(sql) }}
         {{ build_columns_constraints(relation) }}
     {%- else -%}
+        {#- the UNION ALL keeps SELECT INTO from copying an IDENTITY column, which the
+            load's explicit ids would then violate; nullability and types are unchanged -#}
         SELECT TOP 0 * INTO {{ relation }} FROM {{ tmp_relation }}
+        UNION ALL
+        SELECT TOP 0 * FROM {{ tmp_relation }}
     {%- endif -%}
 {%- endmacro %}
 

dbt_sqlserver-1.12.2/dbt/include/sqlserver/macros/utils/array_append.sql

@@ -0,0 +1,3 @@
+{% macro sqlserver__array_append(array, new_element) -%}
+    JSON_MODIFY({{ array }}, 'append $', {{ new_element }})
+{%- endmacro %}

{dbt_sqlserver-1.12.0rc4 → dbt_sqlserver-1.12.2}/dbt_sqlserver.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dbt-sqlserver
-Version: 1.12.0rc4
+Version: 1.12.2
 Summary: A Microsoft SQL Server adapter plugin for dbt
 Author: Mikael Ene, Anders Swanson, Sam Debruyn, Cor Zuurmond, Cody Scott
 License: MIT
@@ -77,7 +77,7 @@ We've bundled all documentation on the dbt docs site:
 - [Profile setup & authentication](https://docs.getdbt.com/reference/warehouse-profiles/mssql-profile)
 - [Adapter documentation, usage and important notes](https://docs.getdbt.com/reference/resource-configs/mssql-configs)
 
-Join us on the [dbt Slack](https://getdbt.slack.com/archives/CMRMDDQ9W) to ask questions, get help, or to discuss the project.
+Ask questions and get help in [GitHub Discussions](https://github.com/dbt-msft/dbt-sqlserver/discussions/categories/q-a). The [dbt Slack](https://getdbt.slack.com/archives/CMRMDDQ9W) channel is there for chatting with the community.
 
 ## Installation
 
@@ -166,11 +166,11 @@ An Arrow-native backend built on [ADBC](https://arrow.apache.org/adbc/), avoidin
 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.
+The driver binary is not on PyPI and must be installed once via the `dbc` CLI. See [docs/adbc_backend.md](https://github.com/dbt-msft/dbt-sqlserver/blob/master/docs/adbc_backend.md) for the full setup, configuration, and known-differences guide.
 
 ## Changelog
 
-See [the changelog](CHANGELOG.md)
+See [the changelog](https://github.com/dbt-msft/dbt-sqlserver/blob/master/CHANGELOG.md)
 
 ## Configuration
 
@@ -201,7 +201,7 @@ The same setting is also honoured via `vars:` for backwards compatibility; the b
 
 ### `backend`
 
-*(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.
+*(default: `pyodbc`)* Set to `mssql-python` or `adbc` (experimental, see [docs/adbc_backend.md](https://github.com/dbt-msft/dbt-sqlserver/blob/master/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`
 
@@ -227,7 +227,7 @@ two paths that commit a full-refresh marker before the load
 existing table), where neither scope can roll it back. `build` stages
 it inside the hook's transaction, for the one case `load` cannot serve: a
 `transaction: true` pre-hook that creates an object the model reads. See
-[docs/transaction_scope.md](docs/transaction_scope.md) for the full flow and
+[docs/transaction_scope.md](https://github.com/dbt-msft/dbt-sqlserver/blob/master/docs/transaction_scope.md) for the full flow and
 the post-hook ordering change.
 
 ### `dbt_sqlserver_use_dbt_transactions`
@@ -240,11 +240,12 @@ The driver connection remains in autocommit mode (`autocommit=true`) in both mod
 
 This is now the default and should be tested carefully with project-specific materializations and hooks. Projects that depend on autocommit-only behavior should set the flag to `false` during migration.
 
+**Compatibility notes:** Enabling `dbt_sqlserver_use_dbt_transactions: true` may expose transaction-state assumptions hidden by autocommit-only mode. Explicit transaction macros may interact with dbt-managed transactions, and cleanup after failed DDL/DML may differ. Review pre/post hooks for in-transaction vs out-of-transaction semantics.
+
 ```yaml
 # dbt_project.yml
 flags:
-  dbt_sqlserver_enable_safe_type_expansion: true
-  dbt_sqlserver_use_dbt_transactions: true # default
+  dbt_sqlserver_use_dbt_transactions: false # legacy autocommit; deprecated
 ```
 
 ### `dbt_sqlserver_use_native_string_types`
@@ -287,7 +288,11 @@ your_profile:
 
 ### `prefer_single_alter_column`
 
-*(default: `false`)* Model-level config that controls how `alter_column_type` changes column types on tables. When `false` (default), the adapter uses the safer approach: add a temporary column, copy data, drop the original, and rename. When `true`, the adapter uses a single `ALTER COLUMN` statement, which is faster on small, medium tables and instant on safe type expansions but may fail for types that cannot be implicitly converted.
+*(default: unset)* Model-level config that controls how `alter_column_type` changes column types on tables:
+
+* `true`: a single `ALTER COLUMN` statement. It is atomic, instant for a longer `varchar`/`nvarchar`, and keeps the column's indexes, default constraint and position. It fails for types that cannot be implicitly converted, and changing `varchar` to `nvarchar` on a large clustered columnstore table can fail with Msg 35357 (dictionary size limit).
+* `false`: add a temporary column, copy the data, drop the original and rename. It fails when an index, default constraint or statistics object depends on the column, and it moves the column to the end of the table. A failed attempt no longer blocks the next run.
+* unset (default): `true` when column type expansion widens a column within its type (a longer `varchar`, or `varchar(max)`), `false` for every other change.
 
 ```sql
 -- In an incremental model
@@ -295,8 +300,6 @@ your_profile:
            prefer_single_alter_column=true) }}
 ```
 
-**Compatibility notes:** Enabling `dbt_sqlserver_use_dbt_transactions: true` may expose transaction-state assumptions hidden by autocommit-only mode. Explicit transaction macros may interact with dbt-managed transactions, and cleanup after failed DDL/DML may differ. Review pre/post hooks for in-transaction vs out-of-transaction semantics.
-
 ### `as_columnstore`
 
 *(default: `true`)* When building a table, the adapter creates a [clustered columnstore index](https://learn.microsoft.com/en-us/sql/relational-databases/indexes/columnstore-indexes-overview) (CCI) on it. Set `as_columnstore: false` to build a plain rowstore table instead.
@@ -322,6 +325,10 @@ You can also set it per model:
 
 With `table_refresh_method: dml`, a schema change makes the refresh fall back to a rename-swap. On that run — and only that run — the scratch table is rebuilt the way this adapter builds every other table, so it carries the model's columnstore index, and under an enforced contract its `NOT NULL`s and inline constraints, into the swap. That run therefore executes the model's SQL twice — once for the `SELECT … INTO` that probes for the schema change, once for the rebuild — and builds the columnstore index once. Steady-state refreshes are unaffected and keep the single `SELECT … INTO`. A table that lost its columnstore index to this bug before you upgraded is not repaired automatically: its schema still matches, so it stays on the cheap path. To rebuild it, temporarily set `full_refresh_build: prebuilt` and run with `--full-refresh`.
 
+### Ephemeral models
+
+Ephemeral models are supported, with one limit: an ephemeral model can't start with its own `WITH`. dbt inlines it as a CTE, and T-SQL can't nest a `WITH` inside one (still true on SQL Server 2025). Write it with derived tables instead, or materialize it as a `view`, which SQL Server expands into the calling query the same way.
+
 ### Constraints
 
 Constraints declared in a model's yaml are applied when — and only when — the model's [contract](https://docs.getdbt.com/reference/resource-configs/contract) is enforced, which is what every dbt adapter does and keeps their cost opt-in. (dbt-core does not raise if you declare constraints with the contract off — they are simply never emitted.) `not_null`, `check`, `unique`, `primary_key` and `foreign_key` are all supported.
@@ -334,7 +341,7 @@ A *model-level* constraint carrying `name:` is applied by `ALTER TABLE … ADD C
 
 Name a constraint when you want it stable across environments (schema-comparison tools report the generated names as differences) or need to reference it later. A `name:` on a *column-level* constraint is ignored with a warning — declare it under the model's `constraints:` key instead.
 
-The full set of rules, with the test that verifies each, is in [docs/constraints.md](docs/constraints.md).
+The full set of rules, with the test that verifies each, is in [docs/constraints.md](https://github.com/dbt-msft/dbt-sqlserver/blob/master/docs/constraints.md).
 
 ```yaml
 models:
@@ -492,8 +499,8 @@ The `denies` config re-applies object-level DENYs after each build, diffed again
 [![Integration tests on SQL Server](https://github.com/dbt-msft/dbt-sqlserver/actions/workflows/integration-tests-sqlserver.yml/badge.svg)](https://github.com/dbt-msft/dbt-sqlserver/actions/workflows/integration-tests-sqlserver.yml)
 
 This adapter is community-maintained.
-You are welcome to contribute by creating issues, opening or reviewing pull requests, or helping other users in the Slack channel.
-If you're unsure how to get started, check out our [contributing guide](CONTRIBUTING.md).
+You are welcome to contribute by creating issues, opening or reviewing pull requests, or helping other users in [Discussions](https://github.com/dbt-msft/dbt-sqlserver/discussions) and on the [dbt Slack](https://getdbt.slack.com/archives/CMRMDDQ9W).
+If you're unsure how to get started, check out our [contributing guide](https://github.com/dbt-msft/dbt-sqlserver/blob/master/CONTRIBUTING.md).
 
 ## License
 

{dbt_sqlserver-1.12.0rc4 → dbt_sqlserver-1.12.2}/dbt_sqlserver.egg-info/SOURCES.txt

@@ -60,6 +60,7 @@ dbt/include/sqlserver/macros/relations/table/clone.sql
 dbt/include/sqlserver/macros/relations/table/create.sql
 dbt/include/sqlserver/macros/relations/views/create.sql
 dbt/include/sqlserver/macros/utils/any_value.sql
+dbt/include/sqlserver/macros/utils/array_append.sql
 dbt/include/sqlserver/macros/utils/array_construct.sql
 dbt/include/sqlserver/macros/utils/cast_bool_to_text.sql
 dbt/include/sqlserver/macros/utils/concat.sql

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

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

dbt_sqlserver-1.12.0rc4/dbt/include/sqlserver/macros/materializations/snapshots/strategies.sql

@@ -1,5 +0,0 @@
-{% macro sqlserver__snapshot_hash_arguments(args) %}
-    CONVERT(VARCHAR(32), HashBytes('MD5', {% for arg in args %}
-        coalesce(cast({{ arg }} as varchar(8000)), '') {% if not loop.last %} + '|' + {% endif %}
-    {% endfor %}), 2)
-{% endmacro %}