dbt-sqlserver 1.9.2__tar.gz → 1.10.0rc1__tar.gz

{dbt_sqlserver-1.9.2/dbt_sqlserver.egg-info → dbt_sqlserver-1.10.0rc1}/PKG-INFO

@@ -1,40 +1,35 @@
 Metadata-Version: 2.4
 Name: dbt-sqlserver
-Version: 1.9.2
+Version: 1.10.0rc1
 Summary: A Microsoft SQL Server adapter plugin for dbt
-Home-page: https://github.com/dbt-msft/dbt-sqlserver
 Author: Mikael Ene, Anders Swanson, Sam Debruyn, Cor Zuurmond, Cody Scott
 License: MIT
 Project-URL: Setup & configuration, https://docs.getdbt.com/reference/warehouse-profiles/mssql-profile
 Project-URL: Documentation & usage, https://docs.getdbt.com/reference/resource-configs/mssql-configs
 Project-URL: Changelog, https://github.com/dbt-msft/dbt-sqlserver/blob/master/CHANGELOG.md
 Project-URL: Issue Tracker, https://github.com/dbt-msft/dbt-sqlserver/issues
+Project-URL: Source, https://github.com/dbt-msft/dbt-sqlserver
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: Microsoft :: Windows
 Classifier: Operating System :: MacOS :: MacOS X
 Classifier: Operating System :: POSIX :: Linux
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: dbt-core<2.0,>=1.9.0
-Requires-Dist: dbt-common<2.0,>=1.0
-Requires-Dist: dbt-adapters<2.0,>=1.11.0
+Requires-Dist: dbt-core<2.0,>=1.10.0
+Requires-Dist: dbt-common<2.0,>=1.22.0
+Requires-Dist: dbt-adapters<2.0,>=1.15.2
 Requires-Dist: pyodbc>=5.2.0
-Dynamic: author
-Dynamic: classifier
-Dynamic: description
-Dynamic: description-content-type
-Dynamic: home-page
-Dynamic: license
+Provides-Extra: azure
+Requires-Dist: azure-identity>=1.12.0; extra == "azure"
+Provides-Extra: pyodbc
+Requires-Dist: pyodbc>=5.2.0; extra == "pyodbc"
 Dynamic: license-file
-Dynamic: project-url
-Dynamic: requires-dist
-Dynamic: summary
 
 # dbt-sqlserver
 

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

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

{dbt_sqlserver-1.9.2 → dbt_sqlserver-1.10.0rc1}/dbt/adapters/sqlserver/sqlserver_adapter.py

@@ -18,7 +18,7 @@ from dbt.adapters.capability import Capability, CapabilityDict, CapabilitySuppor
 from dbt.adapters.events.types import SchemaCreation
 from dbt.adapters.reference_keys import _make_ref_key_dict
 from dbt.adapters.sql.impl import CREATE_SCHEMA_MACRO_NAME, SQLAdapter
-from dbt.adapters.sqlserver.sqlserver_column import SQLServerColumn
+from dbt.adapters.sqlserver.sqlserver_column import SQLServerColumn, SQLServerColumnNative
 from dbt.adapters.sqlserver.sqlserver_configs import SQLServerConfigs
 from dbt.adapters.sqlserver.sqlserver_connections import SQLServerConnectionManager
 from dbt.adapters.sqlserver.sqlserver_relation import SQLServerRelation
@@ -48,6 +48,14 @@ class SQLServerAdapter(SQLAdapter):
         ConstraintType.foreign_key: ConstraintSupport.ENFORCED,
     }
 
+    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
+
     @property
     def _behavior_flags(self) -> List[BehaviorFlag]:
         return [
@@ -71,6 +79,26 @@ class SQLServerAdapter(SQLAdapter):
                     "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,
+                "description": (
+                    "When True, uses SQL Server-native string type mappings: "
+                    "STRING -> VARCHAR(MAX), NCHAR -> NCHAR(1), NVARCHAR -> NVARCHAR(4000). "
+                    "When False (default), preserves legacy mappings: "
+                    "STRING and NVARCHAR -> VARCHAR(8000), NCHAR -> CHAR(1). "
+                    "The new behaviour is intended to become the default in a future release."
+                ),
+            },
         ]
 
     @available.parse(lambda *a, **k: [])

{dbt_sqlserver-1.9.2 → dbt_sqlserver-1.10.0rc1}/dbt/adapters/sqlserver/sqlserver_column.py

@@ -97,3 +97,20 @@ class SQLServerColumn(Column):
         if not self.is_string() or not other_column.is_string():
             return False
         return other_column.string_size() > self.string_size()
+
+
+class SQLServerColumnNative(SQLServerColumn):
+    """STRING maps to VARCHAR(MAX) (matches dbt convention) and NCHAR / NVARCHAR
+    map to their unicode SQL Server types — fixing the legacy default where
+    they were silently aliased to non-unicode CHAR(1) / VARCHAR(8000).
+    NVARCHAR uses the maximum fixed-length form (4000 — the cap for fixed
+    NVARCHAR since unicode is two bytes per character), parallel to VARCHAR(8000).
+    Opt-in via the `dbt_sqlserver_use_native_string_types` behaviour flag;
+    intended to become the default in a future release."""
+
+    TYPE_LABELS: ClassVar[Dict[str, str]] = {
+        **SQLServerColumn.TYPE_LABELS,
+        "STRING": "VARCHAR(MAX)",
+        "NCHAR": "NCHAR(1)",
+        "NVARCHAR": "NVARCHAR(4000)",
+    }

{dbt_sqlserver-1.9.2 → dbt_sqlserver-1.10.0rc1}/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.
@@ -58,19 +65,19 @@ class SQLServerRelation(BaseRelation):
         if event_time_filter.start and event_time_filter.end:
             filter = (
                 f"{event_time_filter.field_name} >="
-                f" cast('{event_time_filter.start}' as datetimeoffset)"
+                f" cast('{event_time_filter.start}' as datetime2)"
                 f" and {event_time_filter.field_name} <"
-                f" cast('{event_time_filter.end}' as datetimeoffset)"
+                f" cast('{event_time_filter.end}' as datetime2)"
             )
         elif event_time_filter.start:
             filter = (
                 f"{event_time_filter.field_name} >="
-                f" cast('{event_time_filter.start}' as datetimeoffset)"
+                f" cast('{event_time_filter.start}' as datetime2)"
             )
         elif event_time_filter.end:
             filter = (
                 f"{event_time_filter.field_name} <"
-                f" cast('{event_time_filter.end}' as datetimeoffset)"
+                f" cast('{event_time_filter.end}' as datetime2)"
             )
 
         return filter

dbt_sqlserver-1.10.0rc1/dbt/include/sqlserver/macros/adapters/catalog.sql

@@ -0,0 +1,277 @@
+{% macro sqlserver__get_catalog(information_schemas, schemas) -%}
+    {% set query_label = get_query_options() %}
+    {%- call statement('catalog', fetch_result=True) -%}
+        {{ get_use_database_sql(information_schemas.database) }}
+        with
+        principals as (
+            select
+                name as principal_name,
+                principal_id as principal_id
+            from
+                sys.database_principals {{ information_schema_hints() }}
+        ),
+
+        schemas as (
+            select
+                name as schema_name,
+                schema_id as schema_id,
+                principal_id as principal_id
+            from
+                sys.schemas {{ information_schema_hints() }}
+        ),
+
+        tables as (
+            select
+                object_id,
+                name as table_name,
+                schema_id as schema_id,
+                principal_id as principal_id,
+                'BASE TABLE' as table_type
+            from
+                sys.tables {{ information_schema_hints() }}
+        ),
+
+        tables_with_metadata as (
+            select
+                object_id,
+                table_name,
+                schema_name,
+                coalesce(tables.principal_id, schemas.principal_id) as owner_principal_id,
+                table_type
+            from
+                tables
+            join schemas on tables.schema_id = schemas.schema_id
+        ),
+
+        views as (
+            select
+                object_id,
+                name as table_name,
+                schema_id as schema_id,
+                principal_id as principal_id,
+                'VIEW' as table_type
+            from
+                sys.views {{ information_schema_hints() }}
+        ),
+
+        views_with_metadata as (
+            select
+                object_id,
+                table_name,
+                schema_name,
+                coalesce(views.principal_id, schemas.principal_id) as owner_principal_id,
+                table_type
+            from
+                views
+            join schemas on views.schema_id = schemas.schema_id
+        ),
+
+        tables_and_views as (
+            select
+                object_id,
+                table_name,
+                schema_name,
+                principal_name,
+                table_type
+            from
+                tables_with_metadata
+            join principals on tables_with_metadata.owner_principal_id = principals.principal_id
+            union all
+            select
+                object_id,
+                table_name,
+                schema_name,
+                principal_name,
+                table_type
+            from
+                views_with_metadata
+            join principals on views_with_metadata.owner_principal_id = principals.principal_id
+        ),
+
+        cols as (
+
+            select
+                c.object_id,
+                c.name as column_name,
+                c.column_id as column_index,
+                t.name as column_type
+            from sys.columns as c {{ information_schema_hints() }}
+            left join sys.types as t {{ information_schema_hints() }} on c.system_type_id = t.system_type_id
+        )
+
+        select
+            DB_NAME() as table_database,
+            tv.schema_name as table_schema,
+            tv.table_name,
+            tv.table_type,
+            null as table_comment,
+            tv.principal_name as table_owner,
+            cols.column_name,
+            cols.column_index,
+            cols.column_type,
+            null as column_comment
+        from tables_and_views tv
+        join cols on tv.object_id = cols.object_id
+        where ({%- for schema in schemas -%}
+            upper(tv.schema_name) = upper('{{ schema }}'){%- if not loop.last %} or {% endif -%}
+        {%- endfor -%})
+
+        order by column_index
+        {{ query_label }}
+
+        {%- endcall -%}
+
+    {{ return(load_result('catalog').table) }}
+
+{%- endmacro %}
+
+{% macro sqlserver__get_catalog_relations(information_schema, relations) -%}
+    {% set query_label = get_query_options() %}
+    {%- set distinct_databases = relations | map(attribute='database') | unique | list -%}
+
+    {%- if distinct_databases | length == 1 -%}
+        {%- call statement('catalog', fetch_result=True) -%}
+            {{ get_use_database_sql(distinct_databases[0]) }}
+            with
+            principals as (
+                select
+                    name as principal_name,
+                    principal_id as principal_id
+                from
+                    sys.database_principals {{ information_schema_hints() }}
+            ),
+
+            schemas as (
+                select
+                    name as schema_name,
+                    schema_id as schema_id,
+                    principal_id as principal_id
+                from
+                    sys.schemas {{ information_schema_hints() }}
+            ),
+
+            tables as (
+                select
+                    object_id,
+                    name as table_name,
+                    schema_id as schema_id,
+                    principal_id as principal_id,
+                    'BASE TABLE' as table_type
+                from
+                    sys.tables {{ information_schema_hints() }}
+            ),
+
+            tables_with_metadata as (
+                select
+                    object_id,
+                    table_name,
+                    schema_name,
+                    coalesce(tables.principal_id, schemas.principal_id) as owner_principal_id,
+                    table_type
+                from
+                    tables
+                join schemas on tables.schema_id = schemas.schema_id
+            ),
+
+            views as (
+                select
+                    object_id,
+                    name as table_name,
+                    schema_id as schema_id,
+                    principal_id as principal_id,
+                    'VIEW' as table_type
+                from
+                    sys.views {{ information_schema_hints() }}
+            ),
+
+            views_with_metadata as (
+                select
+                    object_id,
+                    table_name,
+                    schema_name,
+                    coalesce(views.principal_id, schemas.principal_id) as owner_principal_id,
+                    table_type
+                from
+                    views
+                join schemas on views.schema_id = schemas.schema_id
+            ),
+
+            tables_and_views as (
+                select
+                    object_id,
+                    table_name,
+                    schema_name,
+                    principal_name,
+                    table_type
+                from
+                    tables_with_metadata
+                join principals on tables_with_metadata.owner_principal_id = principals.principal_id
+                union all
+                select
+                    object_id,
+                    table_name,
+                    schema_name,
+                    principal_name,
+                    table_type
+                from
+                    views_with_metadata
+                join principals on views_with_metadata.owner_principal_id = principals.principal_id
+            ),
+
+            cols as (
+
+                select
+                    c.object_id,
+                    c.name as column_name,
+                    c.column_id as column_index,
+                    t.name as column_type
+                from sys.columns as c {{ information_schema_hints() }}
+                left join sys.types as t on c.system_type_id = t.system_type_id
+            )
+
+            select
+                DB_NAME() as table_database,
+                tv.schema_name as table_schema,
+                tv.table_name,
+                tv.table_type,
+                null as table_comment,
+                tv.principal_name as table_owner,
+                cols.column_name,
+                cols.column_index,
+                cols.column_type,
+                null as column_comment
+            from tables_and_views tv
+            join cols on tv.object_id = cols.object_id
+            where (
+                {%- for relation in relations -%}
+                    {% if relation.schema and relation.identifier %}
+                        (
+                            upper(tv.schema_name) = upper('{{ relation.schema }}')
+                            and upper(tv.table_name) = upper('{{ relation.identifier }}')
+                        )
+                    {% elif relation.schema %}
+                        (
+                            upper(tv.schema_name) = upper('{{ relation.schema }}')
+                        )
+                    {% else %}
+                        {% do exceptions.raise_compiler_error(
+                            '`get_catalog_relations` requires a list of relations, each with a schema'
+                        ) %}
+                    {% endif %}
+
+                    {%- if not loop.last %} or {% endif -%}
+                {%- endfor -%}
+            )
+
+            order by column_index
+            {{ query_label }}
+
+        {%- endcall -%}
+        {{ return(load_result('catalog').table) }}
+    {% else %}
+        {% do exceptions.raise_compiler_error(
+            '`get_catalog_relations` can catalog one database at a time'
+        ) %}
+    {% endif %}
+
+{%- endmacro %}

{dbt_sqlserver-1.9.2 → dbt_sqlserver-1.10.0rc1}/dbt/include/sqlserver/macros/adapters/columns.sql

@@ -1,5 +1,6 @@
 {% macro sqlserver__get_empty_subquery_sql(select_sql, select_sql_header=none) %}
-    {% if select_sql.strip().lower().startswith('with') %}
+    {%- set select_sql_stripped = modules.re.sub('(?s)/\\*.*?\\*/|--[^\n]*\n', '', select_sql) -%}
+    {% if select_sql_stripped.strip().lower().startswith('with') %}
         {{ select_sql }}
     {% else -%}
         select * from (
@@ -11,7 +12,7 @@
 {% endmacro %}
 
 {% macro sqlserver__get_columns_in_query(select_sql) %}
-    {% set query_label = apply_label() %}
+    {% set query_label = get_query_options() %}
     {% call statement('get_columns_in_query', fetch_result=True, auto_begin=False) -%}
         select TOP 0 * from (
             {{ select_sql }}
@@ -65,34 +66,23 @@
 {% endmacro %}
 
 {% macro sqlserver__get_columns_in_relation(relation) -%}
-    {% set query_label = apply_label() %}
+    {% 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 %}