dbt-sqlserver 1.8.7__tar.gz → 1.9.1__tar.gz

{dbt-sqlserver-1.8.7 → dbt_sqlserver-1.9.1}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: dbt-sqlserver
-Version: 1.8.7
+Version: 1.9.1
 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
@@ -9,20 +9,32 @@ Project-URL: Setup & configuration, https://docs.getdbt.com/reference/warehouse-
 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
-Platform: UNKNOWN
 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.7
-Classifier: Programming Language :: Python :: 3.8
 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
 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: pyodbc>=5.2.0
+Dynamic: author
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: project-url
+Dynamic: requires-dist
+Dynamic: summary
 
 # dbt-sqlserver
 
@@ -75,6 +87,33 @@ pip install -U --pre dbt-sqlserver
 
 See [the changelog](CHANGELOG.md)
 
+## Configuration
+
+### Flags
+
+- `dbt_sqlserver_use_default_schema_concat`: *(default: `false`)* Controls schema name generation when a [custom schema](https://docs.getdbt.com/docs/build/custom-schemas) is set on a model.
+
+  | Flag value | `custom_schema_name` | Result |
+  |---|---|---|
+  | `false` (default, legacy) | *(none)* | `target.schema` |
+  | `false` (default, legacy) | `"reporting"` | `reporting` |
+  | `true` (dbt-core standard) | *(none)* | `target.schema` |
+  | `true` (dbt-core standard) | `"reporting"` | `target.schema_reporting` |
+
+  When `false` (the default), the adapter uses its legacy behaviour: `custom_schema_name` is used **as-is** without being prefixed by `target.schema`.  
+  When `true`, the adapter delegates to dbt-core's `default__generate_schema_name`, which concatenates `target.schema` + `_` + `custom_schema_name`.
+
+  **Example usage in `dbt_project.yml`:**
+
+  ```yaml
+  vars:
+    dbt_sqlserver_use_default_schema_concat: true  # Enable standard schema concatenation
+  ```
+
+  > **Note:** If you want to permanently customise schema generation and avoid any future deprecation of this flag, override the `sqlserver__generate_schema_name` macro directly in your project.
+
+
+
 ## Contributing
 
 [![Unit tests](https://github.com/dbt-msft/dbt-sqlserver/actions/workflows/unit-tests.yml/badge.svg)](https://github.com/dbt-msft/dbt-sqlserver/actions/workflows/unit-tests.yml)
@@ -92,5 +131,3 @@ If you're unsure how to get started, check out our [contributing guide](CONTRIBU
 ## Code of Conduct
 
 This project and everyone involved is expected to follow the [dbt Code of Conduct](https://community.getdbt.com/code-of-conduct).
-
-

dbt-sqlserver-1.8.7/dbt_sqlserver.egg-info/PKG-INFO → dbt_sqlserver-1.9.1/README.md

@@ -1,29 +1,3 @@
-Metadata-Version: 2.1
-Name: dbt-sqlserver
-Version: 1.8.7
-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
-Platform: UNKNOWN
-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.7
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Description-Content-Type: text/markdown
-License-File: LICENSE
-
 # dbt-sqlserver
 
 [dbt](https://www.getdbt.com) adapter for Microsoft SQL Server and Azure SQL services.
@@ -75,6 +49,33 @@ pip install -U --pre dbt-sqlserver
 
 See [the changelog](CHANGELOG.md)
 
+## Configuration
+
+### Flags
+
+- `dbt_sqlserver_use_default_schema_concat`: *(default: `false`)* Controls schema name generation when a [custom schema](https://docs.getdbt.com/docs/build/custom-schemas) is set on a model.
+
+  | Flag value | `custom_schema_name` | Result |
+  |---|---|---|
+  | `false` (default, legacy) | *(none)* | `target.schema` |
+  | `false` (default, legacy) | `"reporting"` | `reporting` |
+  | `true` (dbt-core standard) | *(none)* | `target.schema` |
+  | `true` (dbt-core standard) | `"reporting"` | `target.schema_reporting` |
+
+  When `false` (the default), the adapter uses its legacy behaviour: `custom_schema_name` is used **as-is** without being prefixed by `target.schema`.  
+  When `true`, the adapter delegates to dbt-core's `default__generate_schema_name`, which concatenates `target.schema` + `_` + `custom_schema_name`.
+
+  **Example usage in `dbt_project.yml`:**
+
+  ```yaml
+  vars:
+    dbt_sqlserver_use_default_schema_concat: true  # Enable standard schema concatenation
+  ```
+
+  > **Note:** If you want to permanently customise schema generation and avoid any future deprecation of this flag, override the `sqlserver__generate_schema_name` macro directly in your project.
+
+
+
 ## Contributing
 
 [![Unit tests](https://github.com/dbt-msft/dbt-sqlserver/actions/workflows/unit-tests.yml/badge.svg)](https://github.com/dbt-msft/dbt-sqlserver/actions/workflows/unit-tests.yml)
@@ -92,5 +93,3 @@ If you're unsure how to get started, check out our [contributing guide](CONTRIBU
 ## Code of Conduct
 
 This project and everyone involved is expected to follow the [dbt Code of Conduct](https://community.getdbt.com/code-of-conduct).
-
-

dbt_sqlserver-1.9.1/dbt/__init__.py

@@ -0,0 +1,3 @@
+from pkgutil import extend_path
+
+__path__ = extend_path(__path__, __name__)

{dbt-sqlserver-1.8.7 → dbt_sqlserver-1.9.1}/dbt/adapters/sqlserver/__init__.py

@@ -1,5 +1,4 @@
 from dbt.adapters.base import AdapterPlugin
-
 from dbt.adapters.sqlserver.sqlserver_adapter import SQLServerAdapter
 from dbt.adapters.sqlserver.sqlserver_column import SQLServerColumn
 from dbt.adapters.sqlserver.sqlserver_configs import SQLServerConfigs
@@ -11,7 +10,7 @@ Plugin = AdapterPlugin(
     adapter=SQLServerAdapter,
     credentials=SQLServerCredentials,
     include_path=sqlserver.PACKAGE_PATH,
-    dependencies=["fabric"],
+    dependencies=[],
 )
 
 __all__ = [

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

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

{dbt-sqlserver-1.8.7 → dbt_sqlserver-1.9.1}/dbt/adapters/sqlserver/relation_configs/policies.py

@@ -1,8 +1,9 @@
 from dataclasses import dataclass
 
-from dbt.adapters.contracts.relation import Policy
 from dbt_common.dataclass_schema import StrEnum
 
+from dbt.adapters.contracts.relation import Policy
+
 MAX_CHARACTERS_IN_IDENTIFIER = 127
 
 

dbt_sqlserver-1.9.1/dbt/adapters/sqlserver/sqlserver_adapter.py

@@ -0,0 +1,290 @@
+from typing import List, Optional
+
+import agate
+import dbt_common.exceptions
+from dbt_common.behavior_flags import BehaviorFlag
+from dbt_common.contracts.constraints import (
+    ColumnLevelConstraint,
+    ConstraintType,
+    ModelLevelConstraint,
+)
+from dbt_common.events.functions import fire_event
+
+from dbt.adapters.base.column import Column as BaseColumn
+from dbt.adapters.base.impl import ConstraintSupport
+from dbt.adapters.base.meta import available
+from dbt.adapters.base.relation import BaseRelation
+from dbt.adapters.capability import Capability, CapabilityDict, CapabilitySupport, Support
+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_configs import SQLServerConfigs
+from dbt.adapters.sqlserver.sqlserver_connections import SQLServerConnectionManager
+from dbt.adapters.sqlserver.sqlserver_relation import SQLServerRelation
+
+
+class SQLServerAdapter(SQLAdapter):
+    """
+    Controls actual implmentation of adapter, and ability to override certain methods.
+    """
+
+    ConnectionManager = SQLServerConnectionManager
+    Column = SQLServerColumn
+    AdapterSpecificConfigs = SQLServerConfigs
+    Relation = SQLServerRelation
+
+    _capabilities: CapabilityDict = CapabilityDict(
+        {
+            Capability.SchemaMetadataByRelations: CapabilitySupport(support=Support.Full),
+            Capability.TableLastModifiedMetadata: CapabilitySupport(support=Support.Full),
+        }
+    )
+    CONSTRAINT_SUPPORT = {
+        ConstraintType.check: ConstraintSupport.ENFORCED,
+        ConstraintType.not_null: ConstraintSupport.ENFORCED,
+        ConstraintType.unique: ConstraintSupport.ENFORCED,
+        ConstraintType.primary_key: ConstraintSupport.ENFORCED,
+        ConstraintType.foreign_key: ConstraintSupport.ENFORCED,
+    }
+
+    @property
+    def _behavior_flags(self) -> List[BehaviorFlag]:
+        return [
+            {
+                "name": "empty",
+                "default": False,
+                "description": (
+                    "When enabled, table and view materializations will be created as empty "
+                    "structures (no data)."
+                ),
+            },
+            {
+                "name": "dbt_sqlserver_use_default_schema_concat",
+                "default": False,
+                "description": (
+                    "When True, uses dbt-core's standard schema concatenation "
+                    "(`target.schema` + `_` + `custom_schema_name`). "
+                    "When False (default), uses legacy adapter behaviour: "
+                    "`custom_schema_name` is used directly without prefixing `target.schema`. "
+                    "For a permanent solution, override the `sqlserver__generate_schema_name` "
+                    "macro in your project instead."
+                ),
+            },
+        ]
+
+    @available.parse(lambda *a, **k: [])
+    def get_column_schema_from_query(self, sql: str) -> List[BaseColumn]:
+        """Get a list of the Columns with names and data types from the given sql."""
+        _, cursor = self.connections.add_select_query(sql)
+
+        columns = [
+            self.Column.create(
+                column_name, self.connections.data_type_code_to_name(column_type_code)
+            )
+            # https://peps.python.org/pep-0249/#description
+            for column_name, column_type_code, *_ in cursor.description
+        ]
+        return columns
+
+    @classmethod
+    def convert_boolean_type(cls, agate_table, col_idx):
+        return "bit"
+
+    @classmethod
+    def convert_datetime_type(cls, agate_table, col_idx):
+        return "datetime2(6)"
+
+    @classmethod
+    def convert_number_type(cls, agate_table, col_idx):
+        decimals = agate_table.aggregate(agate.MaxPrecision(col_idx))
+        return "float" if decimals else "int"
+
+    def create_schema(self, relation: BaseRelation) -> None:
+        relation = relation.without_identifier()
+        fire_event(SchemaCreation(relation=_make_ref_key_dict(relation)))
+        macro_name = CREATE_SCHEMA_MACRO_NAME
+        kwargs = {
+            "relation": relation,
+        }
+
+        if self.config.credentials.schema_authorization:
+            kwargs["schema_authorization"] = self.config.credentials.schema_authorization
+            macro_name = "sqlserver__create_schema_with_authorization"
+
+        self.execute_macro(macro_name, kwargs=kwargs)
+        self.commit_if_has_connection()
+
+    @classmethod
+    def convert_text_type(cls, agate_table, col_idx):
+        column = agate_table.columns[col_idx]
+        # 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
+        length = max_len if max_len > 16 else 16
+        return "varchar({})".format(length)
+
+    @classmethod
+    def convert_time_type(cls, agate_table, col_idx):
+        return "time(6)"
+
+    @classmethod
+    def date_function(cls):
+        return "getdate()"
+
+    # Methods used in adapter tests
+    def timestamp_add_sql(self, add_to: str, number: int = 1, interval: str = "hour") -> str:
+        # note: 'interval' is not supported for T-SQL
+        # for backwards compatibility, we're compelled to set some sort of
+        # default. A lot of searching has lead me to believe that the
+        # '+ interval' syntax used in postgres/redshift is relatively common
+        # and might even be the SQL standard's intention.
+        return f"DATEADD({interval},{number},{add_to})"
+
+    def string_add_sql(
+        self,
+        add_to: str,
+        value: str,
+        location="append",
+    ) -> str:
+        """
+        `+` is T-SQL's string concatenation operator
+        """
+        if location == "append":
+            return f"{add_to} + '{value}'"
+        elif location == "prepend":
+            return f"'{value}' + {add_to}"
+        else:
+            raise ValueError(f'Got an unexpected location value of "{location}"')
+
+    def get_rows_different_sql(
+        self,
+        relation_a: BaseRelation,
+        relation_b: BaseRelation,
+        column_names: Optional[List[str]] = None,
+        except_operator: str = "EXCEPT",
+    ) -> str:
+        """
+        note: using is not supported on Synapse so COLUMNS_EQUAL_SQL is adjsuted
+        Generate SQL for a query that returns a single row with a two
+        columns: the number of rows that are different between the two
+        relations and the number of mismatched rows.
+        """
+        # This method only really exists for test reasons.
+        names: List[str]
+        if column_names is None:
+            columns = self.get_columns_in_relation(relation_a)
+            names = sorted((self.quote(c.name) for c in columns))
+        else:
+            names = sorted((self.quote(n) for n in column_names))
+        columns_csv = ", ".join(names)
+
+        if columns_csv == "":
+            columns_csv = "*"
+
+        sql = COLUMNS_EQUAL_SQL.format(
+            columns=columns_csv,
+            relation_a=str(relation_a),
+            relation_b=str(relation_b),
+            except_op=except_operator,
+        )
+
+        return sql
+
+    def valid_incremental_strategies(self):
+        """The set of standard builtin strategies which this adapter supports out-of-the-box.
+        Not used to validate custom strategies defined by end users.
+        """
+        return ["append", "delete+insert", "merge", "microbatch"]
+
+    # This is for use in the test suite
+    def run_sql_for_tests(self, sql, fetch, conn):
+        cursor = conn.handle.cursor()
+        try:
+            cursor.execute(sql)
+            if not fetch:
+                conn.handle.commit()
+            if fetch == "one":
+                return cursor.fetchone()
+            elif fetch == "all":
+                return cursor.fetchall()
+            else:
+                return
+        except BaseException:
+            if conn.handle and not getattr(conn.handle, "closed", True):
+                conn.handle.rollback()
+            raise
+        finally:
+            conn.transaction_open = False
+
+    @available
+    @classmethod
+    def render_column_constraint(cls, constraint: ColumnLevelConstraint) -> Optional[str]:
+        rendered_column_constraint = None
+        if constraint.type == ConstraintType.not_null:
+            rendered_column_constraint = "not null "
+        else:
+            rendered_column_constraint = ""
+
+        if rendered_column_constraint:
+            rendered_column_constraint = rendered_column_constraint.strip()
+
+        return rendered_column_constraint
+
+    @classmethod
+    def render_model_constraint(cls, constraint: ModelLevelConstraint) -> Optional[str]:
+        constraint_prefix = "add constraint "
+        column_list = ", ".join(constraint.columns)
+
+        if constraint.name is None:
+            raise dbt_common.exceptions.DbtDatabaseError(
+                "Constraint name cannot be empty. Provide constraint name  - column "
+                + column_list
+                + " and run the project again."
+            )
+
+        if constraint.type == ConstraintType.unique:
+            return constraint_prefix + f"{constraint.name} unique nonclustered({column_list})"
+        elif constraint.type == ConstraintType.primary_key:
+            return constraint_prefix + f"{constraint.name} primary key nonclustered({column_list})"
+        elif constraint.type == ConstraintType.foreign_key and constraint.expression:
+            return (
+                constraint_prefix
+                + f"{constraint.name} foreign key({column_list}) references "
+                + constraint.expression
+            )
+        elif constraint.type == ConstraintType.check and constraint.expression:
+            return f"{constraint_prefix} {constraint.name} check ({constraint.expression})"
+        elif constraint.type == ConstraintType.custom and constraint.expression:
+            return f"{constraint_prefix} {constraint.name} {constraint.expression}"
+        else:
+            return None
+
+
+COLUMNS_EQUAL_SQL = """
+with diff_count as (
+    SELECT
+        1 as id,
+        COUNT(*) as num_missing FROM (
+            (SELECT {columns} FROM {relation_a} {except_op}
+             SELECT {columns} FROM {relation_b})
+             UNION ALL
+            (SELECT {columns} FROM {relation_b} {except_op}
+             SELECT {columns} FROM {relation_a})
+        ) as a
+), table_a as (
+    SELECT COUNT(*) as num_rows FROM {relation_a}
+), table_b as (
+    SELECT COUNT(*) as num_rows FROM {relation_b}
+), row_count_diff as (
+    select
+        1 as id,
+        table_a.num_rows - table_b.num_rows as difference
+    from table_a, table_b
+)
+select
+    row_count_diff.difference as row_count_difference,
+    diff_count.num_missing as num_mismatched
+from row_count_diff
+join diff_count on row_count_diff.id = diff_count.id
+""".strip()

dbt_sqlserver-1.9.1/dbt/adapters/sqlserver/sqlserver_column.py

@@ -0,0 +1,99 @@
+from typing import Any, ClassVar, Dict
+
+from dbt_common.exceptions import DbtRuntimeError
+
+from dbt.adapters.base.column import Column
+
+
+class SQLServerColumn(Column):
+    TYPE_LABELS: ClassVar[Dict[str, str]] = {
+        "STRING": "VARCHAR(8000)",
+        "VARCHAR": "VARCHAR(8000)",
+        "CHAR": "CHAR(1)",
+        "NCHAR": "CHAR(1)",
+        "NVARCHAR": "VARCHAR(8000)",
+        "TIMESTAMP": "DATETIME2(6)",
+        "DATETIME2": "DATETIME2(6)",
+        "DATETIME2(6)": "DATETIME2(6)",
+        "DATE": "DATE",
+        "TIME": "TIME(6)",
+        "FLOAT": "FLOAT",
+        "REAL": "REAL",
+        "INT": "INT",
+        "INTEGER": "INT",
+        "BIGINT": "BIGINT",
+        "SMALLINT": "SMALLINT",
+        "TINYINT": "SMALLINT",
+        "BIT": "BIT",
+        "BOOLEAN": "BIT",
+        "DECIMAL": "DECIMAL",
+        "NUMERIC": "NUMERIC",
+        "MONEY": "DECIMAL",
+        "SMALLMONEY": "DECIMAL",
+        "UNIQUEIDENTIFIER": "UNIQUEIDENTIFIER",
+        "VARBINARY": "VARBINARY(MAX)",
+        "BINARY": "BINARY(1)",
+    }
+
+    @classmethod
+    def string_type(cls, size: int) -> str:
+        return f"varchar({size if size > 0 else '8000'})"
+
+    def literal(self, value: Any) -> str:
+        return "cast('{}' as {})".format(value, self.data_type)
+
+    @property
+    def data_type(self) -> str:
+        # Always enforce datetime2 precision
+        if self.dtype.lower() == "datetime2":
+            return "datetime2(6)"
+        if self.is_string():
+            return self.string_type(self.string_size())
+        elif self.is_numeric():
+            return self.numeric_type(self.dtype, self.numeric_precision, self.numeric_scale)
+        else:
+            return self.dtype
+
+    def is_string(self) -> bool:
+        return self.dtype.lower() in ["varchar", "char"]
+
+    def is_number(self):
+        return any([self.is_integer(), self.is_numeric(), self.is_float()])
+
+    def is_float(self):
+        return self.dtype.lower() in ["float", "real"]
+
+    def is_integer(self) -> bool:
+        return self.dtype.lower() in [
+            # real types
+            "smallint",
+            "integer",
+            "bigint",
+            "smallserial",
+            "serial",
+            "bigserial",
+            # aliases
+            "int2",
+            "int4",
+            "int8",
+            "serial2",
+            "serial4",
+            "serial8",
+            "int",
+        ]
+
+    def is_numeric(self) -> bool:
+        return self.dtype.lower() in ["numeric", "decimal", "money", "smallmoney"]
+
+    def string_size(self) -> int:
+        if not self.is_string():
+            raise DbtRuntimeError("Called string_size() on non-string field!")
+        if self.char_size is None:
+            return 8000
+        else:
+            return int(self.char_size)
+
+    def can_expand_to(self, other_column: "SQLServerColumn") -> bool:
+        if not self.is_string() or not other_column.is_string():
+            return False
+        return other_column.string_size() > self.string_size()

dbt_sqlserver-1.9.1/dbt/adapters/sqlserver/sqlserver_configs.py

@@ -0,0 +1,9 @@
+from dataclasses import dataclass
+from typing import Optional
+
+from dbt.adapters.protocol import AdapterConfig
+
+
+@dataclass
+class SQLServerConfigs(AdapterConfig):
+    auto_provision_aad_principals: Optional[bool] = False