Merge branch 'master' into test/tablock-query-options-interaction

axellpadilla · web-flow · commit bdf7b5d6ad7c · 2026-06-02T10:00:50.000-06:00
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -1,5 +1,11 @@
 # Changelog
 
+### v1.10.0
+
+- Add `query_options` / `query_options_raw` model configs for emitting SQL Server `OPTION` clauses on table, incremental (delete+insert / microbatch), snapshot, and unit_test materializations. See https://github.com/dbt-msft/dbt-sqlserver/issues/613.
+- `get_query_options()` is the new extension point for customising the emitted `OPTION` clause.
+- **Migration note:** `apply_label()` is preserved as a callable alias (emits LABEL only) in case you use it in your own project but is no longer called by adapter macros. Projects that override `apply_label()` to customise the OPTION clause must override `get_query_options()` instead.
+
 ### v1.9.1
 
 - Removes the dependency on `dbt-fabric`.
diff --git a/dbt/adapters/sqlserver/sqlserver_adapter.py b/dbt/adapters/sqlserver/sqlserver_adapter.py
@@ -50,6 +50,9 @@ class SQLServerAdapter(SQLAdapter):
 
     def __init__(self, config, mp_context=None):
         super().__init__(config, mp_context)
+        SQLServerRelation.disable_empty_relation_aliases = (
+            self.behavior.dbt_sqlserver_disable_empty_relation_aliases
+        )
         if self.behavior.dbt_sqlserver_use_native_string_types:
             self.Column = SQLServerColumnNative
 
@@ -76,6 +79,15 @@ def _behavior_flags(self) -> List[BehaviorFlag]:
                     "macro in your project instead."
                 ),
             },
+            {
+                "name": "dbt_sqlserver_disable_empty_relation_aliases",
+                "default": True,
+                "description": (
+                    "When True, SQL Server limited relations used by --empty and sample mode "
+                    "do not automatically receive dbt-generated aliases. Set this false to opt "
+                    "out of alias generation temporarily for testing."
+                ),
+            },
             {
                 "name": "dbt_sqlserver_use_native_string_types",
                 "default": False,
diff --git a/dbt/adapters/sqlserver/sqlserver_relation.py b/dbt/adapters/sqlserver/sqlserver_relation.py
@@ -1,5 +1,5 @@
 from dataclasses import dataclass, field
-from typing import Optional, Type
+from typing import ClassVar, Optional, Type
 
 from dbt_common.exceptions import DbtRuntimeError
 
@@ -20,19 +20,26 @@ class SQLServerRelation(BaseRelation):
         default_factory=lambda: SQLServerIncludePolicy()
     )
     quote_policy: SQLServerQuotePolicy = field(default_factory=lambda: SQLServerQuotePolicy())
+    disable_empty_relation_aliases: ClassVar[bool] = True
 
     @classproperty
     def get_relation_type(cls) -> Type[SQLServerRelationType]:
         return SQLServerRelationType
 
+    def _render_limited_alias(self) -> str:
+        if self.disable_empty_relation_aliases:
+            return ""
+
+        return super()._render_limited_alias()
+
     def render_limited(self) -> str:
         rendered = self.render()
         if self.limit is None:
             return rendered
         elif self.limit == 0:
-            return f"(select * from {rendered} where 1=0) AS {self._render_limited_alias()}"
+            return f"(select * from {rendered} where 1=0){self._render_limited_alias()}"
         else:
-            return f"(select TOP {self.limit} * from {rendered}) AS {self._render_limited_alias()}"
+            return f"(select TOP {self.limit} * from {rendered}){self._render_limited_alias()}"
 
     def __post_init__(self):
         # Check for length of Redshift table/view names.
diff --git a/dbt/include/sqlserver/macros/adapters/catalog.sql b/dbt/include/sqlserver/macros/adapters/catalog.sql
@@ -127,7 +127,7 @@
 
 {% macro sqlserver__get_catalog_relations(information_schema, relations) -%}
     {% set query_label = get_query_options() %}
-    {%- call statement('catalog', fetch_result=True) -%}
+    {%- set distinct_databases = relations | map(attribute='database') | unique | list -%}
 
     {%- if distinct_databases | length == 1 -%}
         {%- call statement('catalog', fetch_result=True) -%}
diff --git a/dbt/include/sqlserver/macros/adapters/columns.sql b/dbt/include/sqlserver/macros/adapters/columns.sql
@@ -69,31 +69,20 @@
     {% set query_label = get_query_options() %}
     {% call statement('get_columns_in_relation', fetch_result=True) %}
         {{ get_use_database_sql(relation.database) }}
-        with mapping as (
-            select
-                row_number() over (partition by object_name(c.object_id) order by c.column_id) as ordinal_position,
-                c.name collate database_default as column_name,
-                t.name as data_type,
-                case
-					when (t.name in ('nchar', 'nvarchar', 'sysname') and c.max_length <> -1) then c.max_length / 2
-					else c.max_length
-				end as character_maximum_length,
-                c.precision as numeric_precision,
-                c.scale as numeric_scale
-            from sys.columns c {{ information_schema_hints() }}
-            inner join sys.types t {{ information_schema_hints() }}
-            on c.user_type_id = t.user_type_id
-            where c.object_id = object_id('{{ 'tempdb..' ~ relation.include(database=false, schema=false) if '#' in relation.identifier else relation }}')
-        )
-
         select
-            column_name,
-            data_type,
-            character_maximum_length,
-            numeric_precision,
-            numeric_scale
-        from mapping
-        order by ordinal_position
+            c.name collate database_default as column_name,
+            t.name as data_type,
+            case
+                when (t.name in ('nchar', 'nvarchar', 'sysname') and c.max_length <> -1) then c.max_length / 2
+                else c.max_length
+            end as character_maximum_length,
+            c.precision as numeric_precision,
+            c.scale as numeric_scale
+        from sys.columns c {{ information_schema_hints() }}
+        inner join sys.types t {{ information_schema_hints() }}
+        on c.user_type_id = t.user_type_id
+        where c.object_id = object_id('{{ 'tempdb..' ~ relation.include(database=false, schema=false) if '#' in relation.identifier else relation }}')
+        order by c.column_id
         {{ query_label }}
 
     {% endcall %}
diff --git a/dbt/include/sqlserver/macros/adapters/metadata.sql b/dbt/include/sqlserver/macros/adapters/metadata.sql
@@ -26,7 +26,6 @@
             'MAXRECURSION',
             'NO_PERFORMANCE_SPOOL',
             'OPTIMIZE FOR UNKNOWN',
-            'PARAMETERIZATION',
             'QUERYTRACEON',
             'RECOMPILE',
             'ROBUST PLAN',
@@ -46,11 +45,18 @@
                     {{ exceptions.raise_compiler_error("Query option '" ~ key ~ "' value must be a number, got: '" ~ value ~ "'") }}
                 {%- endif -%}
                 {%- set separator = ' = ' if key | upper in equals_syntax_options else ' ' -%}
-                {%- do options_list.append(key | upper ~ separator ~ value | int) -%}
+                {#- Render the value verbatim: ints become "1", floats become "12.5".
+                    MAX_GRANT_PERCENT / MIN_GRANT_PERCENT accept decimals 0.0–100.0; integer-only
+                    options will surface a clear SQL Server parse error on invalid decimals. -#}
+                {%- do options_list.append(key | upper ~ separator ~ value) -%}
             {%- endif -%}
         {%- endfor -%}
 
-        {#- query_options_raw bypasses the allowlist; users opt in to writing valid SQL Server syntax themselves. -#}
+        {#- query_options_raw bypasses the allowlist; users opt in to writing valid SQL Server syntax themselves.
+            Shape-check only: a plain string would be iterated character-by-character into garbage. -#}
+        {%- if query_options_raw is string or query_options_raw is mapping -%}
+            {{ exceptions.raise_compiler_error("query_options_raw must be a list of strings, got: '" ~ query_options_raw ~ "'") }}
+        {%- endif -%}
         {%- for raw in query_options_raw -%}
             {%- do options_list.append(raw) -%}
         {%- endfor -%}
@@ -59,17 +65,16 @@
     OPTION ({{ options_list | join(', ') }});
 {% endmacro %}
 
-{#- Backward-compat alias for the pre-1.10 macro. Emits only the LABEL hint
-    and ignores query_options / query_options_raw. New adapter code should
-    call get_query_options() directly.
-
-    Note: this preserves non-breaking *consumption* of apply_label (user
-    macros calling `{{ apply_label() }}` still resolve), but does NOT
-    preserve non-breaking *override*: adapter macros no longer call
-    apply_label internally, so a project that overrides apply_label in its
-    own macros directory will find that override has no effect on adapter
-    behaviour. To customise the OPTION clause emitted by adapter macros,
-    override get_query_options instead. -#}
+{#- DEPRECATED: backward-compat alias for the pre-1.10 macro.
+
+    Calls to `{{ apply_label() }}` from user macros still resolve and emit
+    a LABEL-only OPTION clause — but apply_label() is no longer the
+    extension point. Adapter macros now call get_query_options() instead,
+    so overriding apply_label() in a project's macros directory will have
+    no effect on adapter-emitted SQL.
+
+    To customise the OPTION clause emitted by adapter macros (table,
+    incremental, snapshot, unit_test), override get_query_options instead. -#}
 {% macro apply_label() %}
     {{ log (config.get('query_tag','dbt-sqlserver'))}}
     {%- set query_label = config.get('query_tag','dbt-sqlserver') -%}
@@ -125,23 +130,22 @@
 {% macro sqlserver__list_relations_without_caching(schema_relation) -%}
   {% call statement('list_relations_without_caching', fetch_result=True) -%}
     {{ get_use_database_sql(schema_relation.database) }}
-    with base as (
-      select
-        DB_NAME() as [database],
-        t.name as [name],
-        SCHEMA_NAME(t.schema_id) as [schema],
-        'table' as table_type
-      from sys.tables as t {{ information_schema_hints() }}
-      union all
-      select
-        DB_NAME() as [database],
-        v.name as [name],
-        SCHEMA_NAME(v.schema_id) as [schema],
-        'view' as table_type
-      from sys.views as v {{ information_schema_hints() }}
-    )
-    select * from base
-    where [schema] like '{{ schema_relation.schema }}'
+    declare @schema_id int = schema_id('{{ schema_relation.schema }}');
+    select
+      DB_NAME() as [database],
+      t.name as [name],
+      '{{ schema_relation.schema }}' as [schema],
+      'table' as table_type
+    from sys.tables as t {{ information_schema_hints() }}
+    where t.schema_id = @schema_id
+    union all
+    select
+      DB_NAME() as [database],
+      v.name as [name],
+      '{{ schema_relation.schema }}' as [schema],
+      'view' as table_type
+    from sys.views as v {{ information_schema_hints() }}
+    where v.schema_id = @schema_id
     {{ get_query_options() }}
   {% endcall %}
   {{ return(load_result('list_relations_without_caching').table) }}
@@ -150,24 +154,22 @@
 {% macro sqlserver__get_relation_without_caching(schema_relation) -%}
   {% call statement('get_relation_without_caching', fetch_result=True) -%}
     {{ get_use_database_sql(schema_relation.database) }}
-    with base as (
-      select
-        DB_NAME() as [database],
-        t.name as [name],
-        SCHEMA_NAME(t.schema_id) as [schema],
-        'table' as table_type
-      from sys.tables as t {{ information_schema_hints() }}
-      union all
-      select
-        DB_NAME() as [database],
-        v.name as [name],
-        SCHEMA_NAME(v.schema_id) as [schema],
-        'view' as table_type
-      from sys.views as v {{ information_schema_hints() }}
-    )
-    select * from base
-    where [schema] like '{{ schema_relation.schema }}'
-    and [name] like '{{ schema_relation.identifier }}'
+    declare @schema_id int = schema_id('{{ schema_relation.schema }}');
+    select
+      DB_NAME() as [database],
+      t.name as [name],
+      '{{ schema_relation.schema }}' as [schema],
+      'table' as table_type
+    from sys.tables as t {{ information_schema_hints() }}
+    where t.schema_id = @schema_id and t.name = '{{ schema_relation.identifier }}'
+    union all
+    select
+      DB_NAME() as [database],
+      v.name as [name],
+      '{{ schema_relation.schema }}' as [schema],
+      'view' as table_type
+    from sys.views as v {{ information_schema_hints() }}
+    where v.schema_id = @schema_id and v.name = '{{ schema_relation.identifier }}'
     {{ get_query_options() }}
   {% endcall %}
   {{ return(load_result('get_relation_without_caching').table) }}
@@ -178,13 +180,10 @@
 {% endmacro %}
 
 {% macro sqlserver__get_view_definition_sql(relation) -%}
+  {%- set object_name = "quotename('" ~ relation.schema ~ "') + '.' + quotename('" ~ relation.identifier ~ "')" -%}
   {{ get_use_database_sql(relation.database) }}
-  select object_definition(v.object_id) as definition
-  from sys.views as v {{ information_schema_hints() }}
-  inner join sys.schemas as s {{ information_schema_hints() }}
-    on v.schema_id = s.schema_id
-  where upper(s.name) = upper('{{ relation.schema }}')
-    and upper(v.name) = upper('{{ relation.identifier }}')
+  select object_definition(object_id({{ object_name }}, 'V')) as definition
+  where object_id({{ object_name }}, 'V') is not null
 {% endmacro %}
 
 {% macro sqlserver__get_relation_last_modified(information_schema, relations) -%}
diff --git a/pyproject.toml b/pyproject.toml
@@ -27,7 +27,7 @@ classifiers = [
     "Programming Language :: Python :: 3.13",
 ]
 dependencies = [
-    "dbt-core>=1.10.0,<1.11.0",
+    "dbt-core>=1.10.0,<2.0",
     "dbt-common>=1.22.0,<2.0",
     "dbt-adapters>=1.15.2,<2.0",
 ]
diff --git a/tests/functional/adapter/dbt/test_empty.py b/tests/functional/adapter/dbt/test_empty.py
@@ -12,14 +12,21 @@
 
 model_sql_sqlserver = """
 select *
-from {{ ref('model_input') }}
+from {{ ref('model_input') }} as model_input_alias
 union all
 select *
-from {{ source('seed_sources', 'raw_source') }}
+from {{ source('seed_sources', 'raw_source') }} as raw_source_alias
 """
 
 model_inline_sql_sqlserver = """
-select * from {{ source('seed_sources', 'raw_source') }}
+select * from {{ source('seed_sources', 'raw_source') }} as raw_source_alias
+"""
+
+model_sql_user_alias_sqlserver = """
+select user_alias.id as id
+from {{ ref('model_input') }} as user_alias
+inner join {{ source('seed_sources', 'raw_source') }} as source_alias
+    on user_alias.id = source_alias.id
 """
 
 
@@ -47,6 +54,49 @@ def test_run_with_empty(self, project):
         self.assert_row_count(project, "model", 0)
 
 
+class TestEmptyWithUserAlias(BaseTestEmpty):
+    @pytest.fixture(scope="class")
+    def models(self):
+        return {
+            "model_input.sql": model_input_sql,
+            "model.sql": model_sql_user_alias_sqlserver,
+            "sources.yml": schema_sources_yml,
+        }
+
+    def test_run_with_empty(self, project):
+        run_dbt(["seed"])
+
+        run_dbt(["run", "--empty"])
+        self.assert_row_count(project, "model", 0)
+
+
+@pytest.mark.xfail(
+    reason="Upstream dbt empty-mode alias handling needs to be contextual aware.",
+)
+class TestEmptyWithUserAliasAndNoAliasFlag(BaseTestEmpty):
+    @pytest.fixture(scope="class")
+    def models(self):
+        return {
+            "model_input.sql": model_input_sql,
+            "model.sql": model_sql_user_alias_sqlserver,
+            "sources.yml": schema_sources_yml,
+        }
+
+    @pytest.fixture(scope="class")
+    def project_config_update(self):
+        return {
+            "flags": {
+                "dbt_sqlserver_disable_empty_relation_aliases": False,
+            }
+        }
+
+    def test_run_with_empty(self, project):
+        run_dbt(["seed"])
+
+        run_dbt(["run", "--empty"])
+        self.assert_row_count(project, "model", 0)
+
+
 class TestemptyInlineSourceRef(BaseTestEmptyInlineSourceRef):
     @pytest.fixture(scope="class")
     def models(self):
diff --git a/tests/functional/adapter/mssql/test_get_view_definition.py b/tests/functional/adapter/mssql/test_get_view_definition.py
diff --git a/tests/functional/adapter/mssql/test_query_options.py b/tests/functional/adapter/mssql/test_query_options.py

Original file line number	Diff line number	Diff line change
`@@ -27,7 +27,7 @@ classifiers = [`
`27`	`27`	`"Programming Language :: Python :: 3.13",`
`28`	`28`	`]`
`29`	`29`	`dependencies = [`
`30`		`- "dbt-core>=1.10.0,<1.11.0",`
	`30`	`+ "dbt-core>=1.10.0,<2.0",`
`31`	`31`	`"dbt-common>=1.22.0,<2.0",`
`32`	`32`	`"dbt-adapters>=1.15.2,<2.0",`
`33`	`33`	`]`