dbt-sqlserver 1.11.2rc1__tar.gz → 1.11.3__tar.gz

{dbt_sqlserver-1.11.2rc1/dbt_sqlserver.egg-info → dbt_sqlserver-1.11.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dbt-sqlserver
-Version: 1.11.2rc1
+Version: 1.11.3
 Summary: A Microsoft SQL Server adapter plugin for dbt
 Author: Mikael Ene, Anders Swanson, Sam Debruyn, Cor Zuurmond, Cody Scott
 License: MIT
@@ -157,7 +157,7 @@ your_profile:
 
 ## Changelog
 
-See [the changelog](CHANGELOG.md)
+See [the changelog](https://github.com/dbt-msft/dbt-sqlserver/blob/release/v1.11/CHANGELOG.md)
 
 ## Configuration
 
@@ -204,7 +204,7 @@ Safe expansions are further gated by `column_type_expansion_max_rows` (default 1
 
 ### `dbt_sqlserver_use_dbt_transactions`
 
-_(default: `false`)_ When enabled, makes dbt's transaction hooks real at the SQL Server level by emitting `BEGIN TRANSACTION` / `COMMIT TRANSACTION` through the adapter's `add_begin_query` and `add_commit_query` methods. 
+_(default: `false`)_ When enabled, makes dbt's transaction hooks real at the SQL Server level by emitting `BEGIN TRANSACTION` / `COMMIT TRANSACTION` through the adapter's `add_begin_query` and `add_commit_query` methods.
 
 The default is `false`, preserving existing behavior where `begin`/`commit` hooks are logical no-ops and the ODBC driver auto-commits each statement. When `dbt_sqlserver_use_dbt_transactions: true`, the adapter emits real T-SQL transaction statements, and rollback uses `IF @@TRANCOUNT > 0 ROLLBACK TRANSACTION`.
 
@@ -212,10 +212,11 @@ The driver connection remains in autocommit mode (`autocommit=true`) in both mod
 
 This mode is opt-in and should be tested carefully with project-specific materializations and hooks.
 
+**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 # <-- opt-in; default is false
 ```
 
@@ -258,8 +259,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.
@@ -297,7 +296,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/release/v1.11/docs/constraints.md).
 
 ```yaml
 models:
@@ -439,7 +438,7 @@ Behaviour:
 
 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).
+If you're unsure how to get started, check out our [contributing guide](https://github.com/dbt-msft/dbt-sqlserver/blob/release/v1.11/CONTRIBUTING.md).
 
 ## License
 

{dbt_sqlserver-1.11.2rc1 → dbt_sqlserver-1.11.3}/README.md

@@ -120,7 +120,7 @@ your_profile:
 
 ## Changelog
 
-See [the changelog](CHANGELOG.md)
+See [the changelog](https://github.com/dbt-msft/dbt-sqlserver/blob/release/v1.11/CHANGELOG.md)
 
 ## Configuration
 
@@ -167,7 +167,7 @@ Safe expansions are further gated by `column_type_expansion_max_rows` (default 1
 
 ### `dbt_sqlserver_use_dbt_transactions`
 
-_(default: `false`)_ When enabled, makes dbt's transaction hooks real at the SQL Server level by emitting `BEGIN TRANSACTION` / `COMMIT TRANSACTION` through the adapter's `add_begin_query` and `add_commit_query` methods. 
+_(default: `false`)_ When enabled, makes dbt's transaction hooks real at the SQL Server level by emitting `BEGIN TRANSACTION` / `COMMIT TRANSACTION` through the adapter's `add_begin_query` and `add_commit_query` methods.
 
 The default is `false`, preserving existing behavior where `begin`/`commit` hooks are logical no-ops and the ODBC driver auto-commits each statement. When `dbt_sqlserver_use_dbt_transactions: true`, the adapter emits real T-SQL transaction statements, and rollback uses `IF @@TRANCOUNT > 0 ROLLBACK TRANSACTION`.
 
@@ -175,10 +175,11 @@ The driver connection remains in autocommit mode (`autocommit=true`) in both mod
 
 This mode is opt-in and should be tested carefully with project-specific materializations and hooks.
 
+**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 # <-- opt-in; default is false
 ```
 
@@ -221,8 +222,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.
@@ -260,7 +259,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/release/v1.11/docs/constraints.md).
 
 ```yaml
 models:
@@ -402,7 +401,7 @@ Behaviour:
 
 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).
+If you're unsure how to get started, check out our [contributing guide](https://github.com/dbt-msft/dbt-sqlserver/blob/release/v1.11/CONTRIBUTING.md).
 
 ## License
 

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

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

{dbt_sqlserver-1.11.2rc1 → dbt_sqlserver-1.11.3}/dbt/adapters/sqlserver/sqlserver_adapter.py

@@ -1,5 +1,6 @@
 import re
-from typing import Any, Dict, List, Optional
+from contextlib import contextmanager
+from typing import Any, Dict, Iterator, List, Optional
 
 import agate
 import dbt_common.exceptions
@@ -56,7 +57,7 @@ _KEYED_CONSTRAINTS = frozenset(
 # full just to read its column names.
 _SQL_COMMENT = re.compile(r"(?s)/\*.*?\*/|--[^\n]*\n")
 
-# sp_describe_first_result_set reports true SQL Server types; reading
+# The describe reports true SQL Server types; reading
 # ``cursor.description`` reports Python classes, which collapse whole families
 # (every integer width arrives as ``int``, every string type as ``varchar``).
 # Contract comparison comes through this method either way, so the describe
@@ -184,6 +185,13 @@ class SQLServerAdapter(SQLAdapter):
         SQLServerConnectionManager._dbt_sqlserver_use_dbt_transactions = use_dbt_transactions
         self.connections._dbt_sqlserver_use_dbt_transactions = use_dbt_transactions
 
+    @SQLAdapter.behavior.setter
+    def behavior(self, flags: List[BehaviorFlag]) -> None:
+        # The base setter extends `flags` in place, and it is passed the module-level
+        # DEFAULT_BASE_BEHAVIOR_FLAGS, which then grows on every adapter init (#855).
+        # Drop once dbt-adapters stops mutating it.
+        SQLAdapter.behavior.fset(self, list(flags))
+
     @property
     def _behavior_flags(self) -> List[BehaviorFlag]:
         return [
@@ -282,34 +290,42 @@ class SQLServerAdapter(SQLAdapter):
     def _describe_result_set(self, sql: str) -> Optional[List[BaseColumn]]:
         """Read a query's column shape without running it, or None to fall back.
 
-        ``sp_describe_first_result_set`` compiles the query and reports its
-        result shape, which is all this method ever wanted. It is already how
-        ``sqlserver__get_columns_in_query`` handles CTEs (#698).
+        ``sys.dm_exec_describe_first_result_set`` compiles the query and
+        reports its result shape, which is all this method ever wanted. It is
+        the table-valued form of the ``sp_describe_first_result_set`` that
+        ``sqlserver__get_columns_in_query`` uses for CTEs (#698).
 
         Returns None -- deliberately, rather than raising -- whenever the
         describe cannot be trusted to match what executing would have reported:
-        a query it refuses to describe (it cannot see through ``#temp`` tables,
-        where executing works), or a type this backend's driver has no known
-        executed name for. The caller then executes as before, which is
+        a query the describe fails on, or a type this backend's driver has no
+        known executed name for. The caller then executes as before, which is
         slower but never disagrees with itself.
+
+        A query that fails to compile is no exception: executing it fails at
+        compile too, costing nothing, and raises the query's own error --
+        Msg 207 naming the missing column -- through the normal path.
         """
         credentials = self.connections.profile.credentials
 
+        # The function rather than ``exec sp_describe_first_result_set``: the
+        # procedure raises whatever stops it describing, and handling a raised
+        # error closes the connection, so the fallback executed on a closed
+        # handle and reported that instead. The function hands the same
+        # failures back as rows with an error_number, which leaves the
+        # connection alone and needs no parsing of driver message text (which
+        # mssql-python strips of the error number anyway).
+        #
         # Inline rather than bound: mssql-python binds str as varchar and the
-        # procedure demands nvarchar(max). columns.sql:24 escapes it the same
+        # function demands nvarchar(max). columns.sql:24 escapes it the same
         # way for the same reason.
-        describe_sql = "exec sp_describe_first_result_set @tsql = N'{}'".format(
-            sql.replace("'", "''")
-        )
+        describe_sql = (
+            "select is_hidden, name, system_type_name, error_number, error_message"
+            " from sys.dm_exec_describe_first_result_set(N'{}', null, 0)"
+            " order by column_ordinal"
+        ).format(sql.replace("'", "''"))
 
+        _, cursor = self.connections.add_select_query(describe_sql)
         try:
-            _, cursor = self.connections.add_select_query(describe_sql)
-        except Exception as e:
-            logger.debug(f"Could not describe a CTE query, falling back to executing it: {e}")
-            return None
-
-        try:
-            fields = [description[0].lower() for description in cursor.description]
             rows = cursor.fetchall()
         except Exception as e:
             logger.debug(f"Could not read a described result set, executing the query: {e}")
@@ -317,32 +333,35 @@ class SQLServerAdapter(SQLAdapter):
         finally:
             _discard_pending_results(cursor)
 
-        try:
-            hidden, name, type_name = (
-                fields.index("is_hidden"),
-                fields.index("name"),
-                fields.index("system_type_name"),
+        errors = [
+            f"Msg {error_number}: {message}" for *_, error_number, message in rows if error_number
+        ]
+        if errors:
+            # Nothing to tell apart here. A query the describe declines -- one
+            # under SET STATISTICS XML, say -- executes fine; one that does
+            # not compile fails executing too, with its own message.
+            logger.debug(
+                f"Could not describe a CTE query, executing it instead: {'; '.join(errors)}"
             )
-        except ValueError:  # pragma: no cover - shape is fixed by SQL Server
             return None
 
         columns = []
-        for row in rows:
-            if row[hidden]:
+        for hidden, name, type_name, *_ in rows:
+            if hidden:
                 continue
             # "varchar(10)" / "decimal(10,2)" -> "varchar" / "decimal"
-            base_type = str(row[type_name]).split("(")[0].strip().lower()
+            base_type = str(type_name).split("(")[0].strip().lower()
             executed_name = _executed_name_for_system_type(base_type, credentials.backend)
-            if executed_name is None or row[name] is None:
+            if executed_name is None or name is None:
                 logger.debug(
                     f"Describing a CTE query reported {base_type!r}, which has no "
                     "equivalent in the executed path; executing it instead"
                 )
                 return None
-            columns.append(self.Column.create(row[name], executed_name))
+            columns.append(self.Column.create(name, executed_name))
 
         # Every select has at least one column, so nothing described means
-        # sp_describe_first_result_set could not work the shape out. Returning
+        # the describe could not work the shape out. Returning
         # an empty list would read as "this query has no columns" and surface
         # as a baffling contract mismatch; execute instead.
         return columns or None
@@ -357,8 +376,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()
@@ -381,6 +407,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)
 
@@ -804,6 +832,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.11.2rc1 → dbt_sqlserver-1.11.3}/dbt/include/sqlserver/macros/adapters/columns.sql

@@ -40,10 +40,17 @@
 
     {% set prefer_single = config.get('prefer_single_alter_column', false) %}
 
+    {#-- 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) %}
 
@@ -64,11 +71,18 @@
         {% set rename_column %}
             exec sp_rename '{{ relation | replace('"', '') }}.{{ tmp_column }}', '{{ 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(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.11.2rc1 → dbt_sqlserver-1.11.3}/dbt/include/sqlserver/macros/adapters/metadata.sql

@@ -187,6 +187,55 @@
   where object_id({{ object_name }}, 'V') is not null
 {% endmacro %}
 
+{% macro get_view_skip_check_sql(relation, compiled_sql) %}
+    {{ return(adapter.dispatch('get_view_skip_check_sql')(relation, compiled_sql)) }}
+{% endmacro %}
+
+{#- `definition` for the skip decision, and `needs_refresh` when the cached column
+    metadata no longer matches what the body resolves to. Refreshing unconditionally
+    would advance modify_date on every unchanged view.
+    - 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. -#}
+{% 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) }}';
+  select
+      object_definition(object_id({{ object_name }}, 'V')) as definition,
+      case when exists (
+          select 1
+          from (
+              select column_ordinal, name, system_type_id, user_type_id,
+                     max_length, precision, scale, collation_name
+              from sys.dm_exec_describe_first_result_set(
+                  @dbt_sqlserver_skip_check_body, null, 0)
+              where is_hidden = 0 or error_number is not null
+          ) as described
+          full outer join (
+              select row_number() over (order by column_id) as column_ordinal,
+                     name, system_type_id, user_type_id,
+                     max_length, precision, scale, collation_name
+              from sys.columns {{ information_schema_hints() }}
+              where object_id = object_id({{ object_name }}, 'V')
+          ) as cached
+            on described.column_ordinal = cached.column_ordinal
+          where described.column_ordinal is null
+             or cached.column_ordinal is null
+             or described.name collate database_default
+                    <> cached.name collate database_default
+             or described.system_type_id <> cached.system_type_id
+             or described.user_type_id <> cached.user_type_id
+             or described.max_length <> cached.max_length
+             or described.precision <> cached.precision
+             or described.scale <> cached.scale
+             or isnull(described.collation_name, '') collate database_default
+                    <> isnull(cached.collation_name, '') collate database_default
+      ) then 1 else 0 end as needs_refresh
+  where object_id({{ object_name }}, 'V') is not null
+{% endmacro %}
+
 {% macro sqlserver__get_relation_last_modified(information_schema, relations) -%}
   {%- call statement('last_modified', fetch_result=True) -%}
         select

{dbt_sqlserver-1.11.2rc1 → dbt_sqlserver-1.11.3}/dbt/include/sqlserver/macros/adapters/schema.sql

@@ -1,20 +1,45 @@
-{% macro sqlserver__create_schema(relation) -%}
-  {% call statement('create_schema') -%}
-    USE [{{ relation.database }}];
-    IF NOT EXISTS (SELECT * FROM sys.schemas WHERE name = '{{ relation.schema }}')
+{#
+    SQL Server has no `CREATE SCHEMA IF NOT EXISTS`, and check-then-act races under
+    concurrency (Msg 2714), so an applock serializes the check and the create.
+    The lock is session-scoped: a transaction-scoped one would be held until dbt
+    commits, after the test query in `get_test_sql`. `XACT_ABORT` skips a trailing
+    release when the create fails, so the `CATCH` releases and rethrows. A timed-out
+    request falls through to the bare check.
+#}
+{% macro create_schema_if_not_exists(schema, authorization=none) -%}
+  {%- set lock_resource = 'dbt_create_schema_' ~ schema -%}
+  DECLARE @dbt_schema_lock int;
+  EXEC @dbt_schema_lock = sp_getapplock
+    @Resource = '{{ escape_single_quotes(lock_resource) }}',
+    @LockMode = 'Exclusive',
+    @LockOwner = 'Session',
+    @LockTimeout = 30000;
+  BEGIN TRY
+    IF NOT EXISTS (SELECT * FROM sys.schemas WHERE name = '{{ escape_single_quotes(schema) }}')
     BEGIN
-    EXEC('CREATE SCHEMA [{{ relation.schema }}]')
+      EXEC('CREATE SCHEMA {{ escape_single_quotes(adapter.quote(schema)) }}{% if authorization is not none %} AUTHORIZATION {{ escape_single_quotes(adapter.quote(authorization)) }}{% endif %}')
     END
+  END TRY
+  BEGIN CATCH
+    IF @dbt_schema_lock >= 0
+      EXEC sp_releaseapplock @Resource = '{{ escape_single_quotes(lock_resource) }}', @LockOwner = 'Session';
+    THROW;
+  END CATCH
+  IF @dbt_schema_lock >= 0
+    EXEC sp_releaseapplock @Resource = '{{ escape_single_quotes(lock_resource) }}', @LockOwner = 'Session';
+{%- endmacro %}
+
+{% macro sqlserver__create_schema(relation) -%}
+  {% call statement('create_schema') -%}
+    {{ get_use_database_sql(relation.database) }}
+    {{ create_schema_if_not_exists(relation.schema) }}
   {% endcall %}
 {% endmacro %}
 
 {% macro sqlserver__create_schema_with_authorization(relation, schema_authorization) -%}
   {% call statement('create_schema') -%}
     {{ get_use_database_sql(relation.database) }}
-    IF NOT EXISTS (SELECT * FROM sys.schemas WHERE name = '{{ relation.schema }}')
-    BEGIN
-    EXEC('CREATE SCHEMA [{{ relation.schema }}] AUTHORIZATION [{{ schema_authorization }}]')
-    END
+    {{ create_schema_if_not_exists(relation.schema, schema_authorization) }}
   {% endcall %}
 {% endmacro %}
 

{dbt_sqlserver-1.11.2rc1 → dbt_sqlserver-1.11.3}/dbt/include/sqlserver/macros/materializations/models/view/view.sql

@@ -41,7 +41,8 @@
     {% endfor %}
     {% set build_sql = get_create_view_as_sql(intermediate_relation, sql) %}
   {% elif existing_relation is not none and existing_relation.type == 'view' %}
-    {% set current_view_definition_table = run_query(get_view_definition_sql(existing_relation)) %}
+    {% set current_view_definition_table = run_query(get_view_skip_check_sql(existing_relation, sql)) %}
+    {% set view_metadata_is_stale = false %}
     {% if current_view_definition_table is not none and current_view_definition_table.rows | length > 0 %}
       {#- Compare the view *body* exactly, not by suffix. The stored definition is
           the whole statement (CREATE [OR ALTER] VIEW <name> AS <body>); the model is
@@ -67,23 +68,15 @@
         {% set model_body = (model_body[:-1] if model_body.endswith(';') else model_body) | trim %}
         {% set should_skip_view_update = stored_body == model_body %}
       {% endif %}
+      {% set view_metadata_is_stale = current_view_definition_table.rows[0][1] == 1 %}
     {% endif %}
-    {% if should_skip_view_update %}
-      {#- The view's SQL text is unchanged, so the CREATE/ALTER is skipped -
-          but a *referenced* table can still have changed shape (columns
-          added, dropped, or reordered) since this view was last built. SQL
-          Server resolves an unqualified `select *` at CREATE/ALTER time and
-          caches the result; skipping that statement here means the cached
-          column list silently goes stale relative to the underlying table,
-          even though this view's own definition never changed. sp_refreshview
-          re-derives that cached metadata from the table's current shape
-          without re-running the CREATE, so a skip stays a skip (no DDL, no
-          grant/deny churn) while the view keeps reporting the right columns. -#}
-      {#- sp_refreshview resolves its argument in the *current* database, so this needs
-          the same USE prefix every other name-resolving statement here carries -
-          without it a cross-database view model would refresh nothing and error. -#}
+    {% if should_skip_view_update and view_metadata_is_stale %}
+      {#- A source changed shape under an unchanged body (e.g. a `select *` expansion).
+          sp_refreshview resolves its argument in the current database, hence the USE. -#}
       {% set object_name = "quotename('" ~ target_relation.schema ~ "') + '.' + quotename('" ~ target_relation.identifier ~ "')" %}
       {% set build_sql = get_use_database_sql(target_relation.database) ~ " declare @dbt_sqlserver_refresh_target nvarchar(max) = " ~ object_name ~ "; exec sp_refreshview @dbt_sqlserver_refresh_target;" %}
+    {% elif should_skip_view_update %}
+      {% set build_sql = 'declare @dbt_sqlserver_noop int;' %}
     {% else %}
       {% set build_sql = get_create_view_as_sql(target_relation, sql) %}
     {% endif %}

{dbt_sqlserver-1.11.2rc1 → dbt_sqlserver-1.11.3}/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.11.3/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.11.2rc1 → dbt_sqlserver-1.11.3}/dbt/include/sqlserver/macros/materializations/tests.sql

@@ -1,11 +1,8 @@
 {% macro sqlserver__get_test_sql(main_sql, fail_calc, warn_if, error_if, limit) -%}
 
-  -- Create target schema if it does not
-  USE [{{ target.database }}];
-  IF NOT EXISTS (SELECT * FROM sys.schemas WHERE name = '{{ target.schema }}')
-  BEGIN
-    EXEC('CREATE SCHEMA [{{ target.schema }}]')
-  END
+  -- Create target schema if it does not exist
+  {{ get_use_database_sql(target.database) }}
+  {{ create_schema_if_not_exists(target.schema) }}
 
   {% set testview %}
     [{{ target.schema }}].[testview_{{ local_md5(main_sql) }}_{{ range(1300, 19000) | random }}]

{dbt_sqlserver-1.11.2rc1 → dbt_sqlserver-1.11.3}/dbt/include/sqlserver/macros/materializations/unit_tests.sql

@@ -1,10 +1,7 @@
 {% macro sqlserver__get_unit_test_sql(main_sql, expected_fixture_sql, expected_column_names) -%}
 
-  USE [{{ target.database }}];
-  IF NOT EXISTS (SELECT * FROM sys.schemas WHERE name = '{{ target.schema }}')
-  BEGIN
-  EXEC('CREATE SCHEMA [{{ target.schema }}]')
-  END
+  {{ get_use_database_sql(target.database) }}
+  {{ create_schema_if_not_exists(target.schema) }}
 
   {% set test_view %}
       [{{ target.schema }}].[testview_{{ local_md5(main_sql) }}_{{ range(1300, 19000) | random }}]

{dbt_sqlserver-1.11.2rc1 → dbt_sqlserver-1.11.3}/dbt/include/sqlserver/macros/relations/table/create.sql

@@ -209,13 +209,21 @@
     {#- mark a table as having a full refresh in flight; the marker rides the
         object, so a successful swap (old table dropped) or in-place rebuild
         (table dropped) clears it naturally -#}
+    {#- USE persists for the session, so without it both halves resolve
+        against wherever the last statement left the connection - and there
+        they disagree: OBJECT_ID returns NULL, so the guard runs the EXEC even
+        when the marker is present, and the proc rejects the same name as
+        absent (Msg 15135). -#}
     {% do run_query(
-        "if not exists (select 1 from sys.extended_properties where major_id = OBJECT_ID('"
-        ~ relation.schema ~ "." ~ relation.identifier
-        ~ "') and name = 'dbt_full_refresh_incomplete')"
+        get_use_database_sql(relation.database)
+        ~ " if not exists (select 1 from sys.extended_properties"
+        ~ " where class = 1 and minor_id = 0"
+        ~ " and name = 'dbt_full_refresh_incomplete' and major_id = OBJECT_ID('"
+        ~ escape_single_quotes(relation.include(database=False))
+        ~ "'))"
         ~ " EXEC sp_addextendedproperty @name = N'dbt_full_refresh_incomplete', @value = '1',"
-        ~ " @level0type = N'SCHEMA', @level0name = N'" ~ relation.schema ~ "',"
-        ~ " @level1type = N'TABLE', @level1name = N'" ~ relation.identifier ~ "'"
+        ~ " @level0type = N'SCHEMA', @level0name = N'" ~ escape_single_quotes(relation.schema) ~ "',"
+        ~ " @level1type = N'TABLE', @level1name = N'" ~ escape_single_quotes(relation.identifier) ~ "'"
     ) %}
     {#- This marker exists to survive a failed rebuild, so it must not ride on
         the same transaction as the rebuild it's guarding: if a prior
@@ -234,10 +242,16 @@
 
 
 {% macro sqlserver__assert_no_incomplete_full_refresh(relation) -%}
+    {#- Needs the USE more than the marker does: off-database this returns 0
+        rather than erroring, which reads as "no marker" and lets the append
+        through. -#}
     {%- set marker = run_query(
-        "select count(*) as marker_count from sys.extended_properties where major_id = OBJECT_ID('"
-        ~ relation.schema ~ "." ~ relation.identifier
-        ~ "') and name = 'dbt_full_refresh_incomplete'"
+        get_use_database_sql(relation.database)
+        ~ " select count(*) as marker_count from sys.extended_properties"
+        ~ " where class = 1 and minor_id = 0"
+        ~ " and name = 'dbt_full_refresh_incomplete' and major_id = OBJECT_ID('"
+        ~ escape_single_quotes(relation.include(database=False))
+        ~ "')"
     ) -%}
     {%- if marker.rows[0][0] > 0 -%}
         {{ exceptions.raise_compiler_error(

dbt_sqlserver-1.11.3/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.11.2rc1 → dbt_sqlserver-1.11.3/dbt_sqlserver.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dbt-sqlserver
-Version: 1.11.2rc1
+Version: 1.11.3
 Summary: A Microsoft SQL Server adapter plugin for dbt
 Author: Mikael Ene, Anders Swanson, Sam Debruyn, Cor Zuurmond, Cody Scott
 License: MIT
@@ -157,7 +157,7 @@ your_profile:
 
 ## Changelog
 
-See [the changelog](CHANGELOG.md)
+See [the changelog](https://github.com/dbt-msft/dbt-sqlserver/blob/release/v1.11/CHANGELOG.md)
 
 ## Configuration
 
@@ -204,7 +204,7 @@ Safe expansions are further gated by `column_type_expansion_max_rows` (default 1
 
 ### `dbt_sqlserver_use_dbt_transactions`
 
-_(default: `false`)_ When enabled, makes dbt's transaction hooks real at the SQL Server level by emitting `BEGIN TRANSACTION` / `COMMIT TRANSACTION` through the adapter's `add_begin_query` and `add_commit_query` methods. 
+_(default: `false`)_ When enabled, makes dbt's transaction hooks real at the SQL Server level by emitting `BEGIN TRANSACTION` / `COMMIT TRANSACTION` through the adapter's `add_begin_query` and `add_commit_query` methods.
 
 The default is `false`, preserving existing behavior where `begin`/`commit` hooks are logical no-ops and the ODBC driver auto-commits each statement. When `dbt_sqlserver_use_dbt_transactions: true`, the adapter emits real T-SQL transaction statements, and rollback uses `IF @@TRANCOUNT > 0 ROLLBACK TRANSACTION`.
 
@@ -212,10 +212,11 @@ The driver connection remains in autocommit mode (`autocommit=true`) in both mod
 
 This mode is opt-in and should be tested carefully with project-specific materializations and hooks.
 
+**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 # <-- opt-in; default is false
 ```
 
@@ -258,8 +259,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.
@@ -297,7 +296,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/release/v1.11/docs/constraints.md).
 
 ```yaml
 models:
@@ -439,7 +438,7 @@ Behaviour:
 
 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).
+If you're unsure how to get started, check out our [contributing guide](https://github.com/dbt-msft/dbt-sqlserver/blob/release/v1.11/CONTRIBUTING.md).
 
 ## License
 

{dbt_sqlserver-1.11.2rc1 → dbt_sqlserver-1.11.3}/dbt_sqlserver.egg-info/SOURCES.txt

@@ -58,6 +58,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.11.2rc1 → dbt_sqlserver-1.11.3}/pyproject.toml

@@ -68,6 +68,7 @@ dev = [
     "pytz",
     "ruff",
     "tox>=3.13",
+    "towncrier>=26.9.0",
     "twine",
 ]
 
@@ -94,6 +95,32 @@ link-mode = "copy"
 environments = "python_version >= '3.11'"
 override-dependencies = ["pathspec>=0.9,<1.1"] # Remove on dbt-core v1.12 or migration to ty by astral
 
+[tool.towncrier]
+directory = "changes"
+filename = "CHANGELOG.md"
+title_format = "### v{version}"
+issue_format = "[#{issue}](https://github.com/dbt-msft/dbt-sqlserver/issues/{issue})"
+
+[[tool.towncrier.type]]
+directory = "behavior"
+name = "Behavior changes"
+showcontent = true
+
+[[tool.towncrier.type]]
+directory = "feature"
+name = "Features"
+showcontent = true
+
+[[tool.towncrier.type]]
+directory = "bugfix"
+name = "Bugfixes"
+showcontent = true
+
+[[tool.towncrier.type]]
+directory = "misc"
+name = "Under the hood"
+showcontent = true
+
 [tool.ruff]
 line-length = 99
 target-version = "py311"

dbt_sqlserver-1.11.2rc1/dbt/adapters/sqlserver/__version__.py

@@ -1 +0,0 @@
-version = "1.11.2rc1"

dbt_sqlserver-1.11.2rc1/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 %}