dbt-sqlserver 1.7.4__tar.gz → 1.8.0rc2__tar.gz

{dbt-sqlserver-1.7.4/dbt_sqlserver.egg-info → dbt-sqlserver-1.8.0rc2}/PKG-INFO

@@ -1,9 +1,9 @@
 Metadata-Version: 2.1
 Name: dbt-sqlserver
-Version: 1.7.4
+Version: 1.8.0rc2
 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
+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
@@ -42,9 +42,9 @@ Join us on the [dbt Slack](https://getdbt.slack.com/archives/CMRMDDQ9W) to ask q
 ## Installation
 
 This adapter requires the Microsoft ODBC driver to be installed:
-[Windows](https://docs.microsoft.com/nl-be/sql/connect/odbc/download-odbc-driver-for-sql-server?view=sql-server-ver16#download-for-windows) |
-[macOS](https://docs.microsoft.com/nl-be/sql/connect/odbc/linux-mac/install-microsoft-odbc-driver-sql-server-macos?view=sql-server-ver16) |
-[Linux](https://docs.microsoft.com/nl-be/sql/connect/odbc/linux-mac/installing-the-microsoft-odbc-driver-for-sql-server?view=sql-server-ver16)
+[Windows](https://docs.microsoft.com/en-us/sql/connect/odbc/download-odbc-driver-for-sql-server?view=sql-server-ver16#download-for-windows) |
+[macOS](https://docs.microsoft.com/en-us/sql/connect/odbc/linux-mac/install-microsoft-odbc-driver-sql-server-macos?view=sql-server-ver16) |
+[Linux](https://docs.microsoft.com/en-us/sql/connect/odbc/linux-mac/installing-the-microsoft-odbc-driver-for-sql-server?view=sql-server-ver16)
 
 <details><summary>Debian/Ubuntu</summary>
 <p>

{dbt-sqlserver-1.7.4 → dbt-sqlserver-1.8.0rc2}/README.md

@@ -17,9 +17,9 @@ Join us on the [dbt Slack](https://getdbt.slack.com/archives/CMRMDDQ9W) to ask q
 ## Installation
 
 This adapter requires the Microsoft ODBC driver to be installed:
-[Windows](https://docs.microsoft.com/nl-be/sql/connect/odbc/download-odbc-driver-for-sql-server?view=sql-server-ver16#download-for-windows) |
-[macOS](https://docs.microsoft.com/nl-be/sql/connect/odbc/linux-mac/install-microsoft-odbc-driver-sql-server-macos?view=sql-server-ver16) |
-[Linux](https://docs.microsoft.com/nl-be/sql/connect/odbc/linux-mac/installing-the-microsoft-odbc-driver-for-sql-server?view=sql-server-ver16)
+[Windows](https://docs.microsoft.com/en-us/sql/connect/odbc/download-odbc-driver-for-sql-server?view=sql-server-ver16#download-for-windows) |
+[macOS](https://docs.microsoft.com/en-us/sql/connect/odbc/linux-mac/install-microsoft-odbc-driver-sql-server-macos?view=sql-server-ver16) |
+[Linux](https://docs.microsoft.com/en-us/sql/connect/odbc/linux-mac/installing-the-microsoft-odbc-driver-for-sql-server?view=sql-server-ver16)
 
 <details><summary>Debian/Ubuntu</summary>
 <p>

{dbt-sqlserver-1.7.4 → dbt-sqlserver-1.8.0rc2}/dbt/adapters/sqlserver/__init__.py

@@ -1,10 +1,10 @@
 from dbt.adapters.base import AdapterPlugin
 
-from dbt.adapters.sqlserver.sql_server_adapter import SQLServerAdapter
-from dbt.adapters.sqlserver.sql_server_column import SQLServerColumn
-from dbt.adapters.sqlserver.sql_server_configs import SQLServerConfigs
-from dbt.adapters.sqlserver.sql_server_connection_manager import SQLServerConnectionManager
-from dbt.adapters.sqlserver.sql_server_credentials import SQLServerCredentials
+from dbt.adapters.sqlserver.sqlserver_adapter import SQLServerAdapter
+from dbt.adapters.sqlserver.sqlserver_column import SQLServerColumn
+from dbt.adapters.sqlserver.sqlserver_configs import SQLServerConfigs
+from dbt.adapters.sqlserver.sqlserver_connections import SQLServerConnectionManager  # noqa
+from dbt.adapters.sqlserver.sqlserver_credentials import SQLServerCredentials
 from dbt.include import sqlserver
 
 Plugin = AdapterPlugin(

dbt-sqlserver-1.8.0rc2/dbt/adapters/sqlserver/__version__.py

@@ -0,0 +1 @@
+version = "1.8.0rc2"

dbt-sqlserver-1.8.0rc2/dbt/adapters/sqlserver/relation_configs/__init__.py

@@ -0,0 +1,13 @@
+from dbt.adapters.sqlserver.relation_configs.policies import (
+    MAX_CHARACTERS_IN_IDENTIFIER,
+    SQLServerIncludePolicy,
+    SQLServerQuotePolicy,
+    SQLServerRelationType,
+)
+
+__all__ = [
+    "MAX_CHARACTERS_IN_IDENTIFIER",
+    "SQLServerIncludePolicy",
+    "SQLServerQuotePolicy",
+    "SQLServerRelationType",
+]

dbt-sqlserver-1.8.0rc2/dbt/adapters/sqlserver/relation_configs/policies.py

@@ -0,0 +1,25 @@
+from dataclasses import dataclass
+
+from dbt.adapters.contracts.relation import Policy
+from dbt_common.dataclass_schema import StrEnum
+
+MAX_CHARACTERS_IN_IDENTIFIER = 127
+
+
+class SQLServerRelationType(StrEnum):
+    Table = "table"
+    View = "view"
+    CTE = "cte"
+
+
+class SQLServerIncludePolicy(Policy):
+    database: bool = True
+    schema: bool = True
+    identifier: bool = True
+
+
+@dataclass
+class SQLServerQuotePolicy(Policy):
+    database: bool = True
+    schema: bool = True
+    identifier: bool = True

dbt-sqlserver-1.8.0rc2/dbt/adapters/sqlserver/sqlserver_adapter.py

@@ -0,0 +1,61 @@
+from typing import Optional
+
+import dbt.exceptions
+from dbt.adapters.base.impl import ConstraintSupport
+from dbt.adapters.fabric import FabricAdapter
+from dbt.contracts.graph.nodes import ConstraintType
+
+from dbt.adapters.sqlserver.sqlserver_column import SQLServerColumn
+from dbt.adapters.sqlserver.sqlserver_connections import SQLServerConnectionManager
+from dbt.adapters.sqlserver.sqlserver_relation import SQLServerRelation
+
+
+class SQLServerAdapter(FabricAdapter):
+    """
+    Controls actual implmentation of adapter, and ability to override certain methods.
+    """
+
+    ConnectionManager = SQLServerConnectionManager
+    Column = SQLServerColumn
+    Relation = SQLServerRelation
+
+    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,
+    }
+
+    @classmethod
+    def render_model_constraint(cls, constraint) -> Optional[str]:
+        constraint_prefix = "add constraint "
+        column_list = ", ".join(constraint.columns)
+
+        if constraint.name is None:
+            raise dbt.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
+
+    @classmethod
+    def date_function(cls):
+        return "getdate()"

dbt-sqlserver-1.8.0rc2/dbt/adapters/sqlserver/sqlserver_column.py

@@ -0,0 +1,22 @@
+from dbt.adapters.fabric import FabricColumn
+
+
+class SQLServerColumn(FabricColumn):
+    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",
+        ]

dbt-sqlserver-1.7.4/dbt/adapters/sqlserver/sql_server_configs.py → dbt-sqlserver-1.8.0rc2/dbt/adapters/sqlserver/sqlserver_configs.py

@@ -5,4 +5,4 @@ from dbt.adapters.fabric import FabricConfigs
 
 @dataclass
 class SQLServerConfigs(FabricConfigs):
-    ...
+    pass

dbt-sqlserver-1.7.4/dbt/adapters/sqlserver/sql_server_connection_manager.py → dbt-sqlserver-1.8.0rc2/dbt/adapters/sqlserver/sqlserver_connections.py

@@ -1,8 +1,9 @@
-from typing import Callable, Mapping
-
+import dbt_common.exceptions  # noqa
 import pyodbc
 from azure.core.credentials import AccessToken
 from azure.identity import ClientSecretCredential, ManagedIdentityCredential
+from dbt.adapters.contracts.connection import Connection, ConnectionState
+from dbt.adapters.events.logging import AdapterLogger
 from dbt.adapters.fabric import FabricConnectionManager
 from dbt.adapters.fabric.fabric_connection_manager import (
     AZURE_AUTH_FUNCTIONS as AZURE_AUTH_FUNCTIONS_FABRIC,
@@ -12,15 +13,11 @@ from dbt.adapters.fabric.fabric_connection_manager import (
     bool_to_connection_string_arg,
     get_pyodbc_attrs_before,
 )
-from dbt.contracts.connection import Connection, ConnectionState
-from dbt.events import AdapterLogger
 
 from dbt.adapters.sqlserver import __version__
-from dbt.adapters.sqlserver.sql_server_credentials import SQLServerCredentials
-
-AZURE_AUTH_FUNCTION_TYPE = Callable[[SQLServerCredentials], AccessToken]
+from dbt.adapters.sqlserver.sqlserver_credentials import SQLServerCredentials
 
-logger = AdapterLogger("SQLServer")
+logger = AdapterLogger("sqlserver")
 
 
 def get_msi_access_token(credentials: SQLServerCredentials) -> AccessToken:
@@ -63,7 +60,7 @@ def get_sp_access_token(credentials: SQLServerCredentials) -> AccessToken:
     return token
 
 
-AZURE_AUTH_FUNCTIONS: Mapping[str, AZURE_AUTH_FUNCTION_TYPE] = {
+AZURE_AUTH_FUNCTIONS = {
     **AZURE_AUTH_FUNCTIONS_FABRIC,
     "serviceprincipal": get_sp_access_token,
     "msi": get_msi_access_token,
@@ -73,6 +70,27 @@ AZURE_AUTH_FUNCTIONS: Mapping[str, AZURE_AUTH_FUNCTION_TYPE] = {
 class SQLServerConnectionManager(FabricConnectionManager):
     TYPE = "sqlserver"
 
+    # @contextmanager
+    # def exception_handler(self, sql: str):
+    #     """
+    #     Returns a context manager, that will handle exceptions raised
+    #     from queries, catch, log, and raise dbt exceptions it knows how to handle.
+    #     """
+    #     # ## Example ##
+    #     # try:
+    #     #     yield
+    #     # except myadapter_library.DatabaseError as exc:
+    #     #     self.release(connection_name)
+
+    #     #     logger.debug("myadapter error: {}".format(str(e)))
+    #     #     raise dbt.exceptions.DatabaseException(str(exc))
+    #     # except Exception as exc:
+    #     #     logger.debug("Error running SQL: {}".format(sql))
+    #     #     logger.debug("Rolling back transaction.")
+    #     #     self.release(connection_name)
+    #     #     raise dbt.exceptions.RuntimeException(str(exc))
+    #     pass
+
     @classmethod
     def open(cls, connection: Connection) -> Connection:
         if connection.state == ConnectionState.OPEN:
@@ -112,7 +130,7 @@ class SQLServerConnectionManager(FabricConnectionManager):
 
         plugin_version = __version__.version
         application_name = f"dbt-{credentials.type}/{plugin_version}"
-        con_str.append(f"Application Name={application_name}")
+        con_str.append(f"APP={application_name}")
 
         con_str_concat = ";".join(con_str)
 
@@ -156,3 +174,28 @@ class SQLServerConnectionManager(FabricConnectionManager):
             retry_limit=credentials.retries,
             retryable_exceptions=retryable_exceptions,
         )
+
+    # @classmethod
+    # def get_response(cls,cursor):
+    #     """
+    #     Gets a cursor object and returns adapter-specific information
+    #     about the last executed command generally a AdapterResponse ojbect
+    #     that has items such as code, rows_affected,etc. can also just be a string ex. "OK"
+    #     if your cursor does not offer rich metadata.
+    #     """
+    #     # ## Example ##
+    #     # return cursor.status_message
+    #     pass
+
+    # def cancel(self, connection):
+    #     """
+    #     Gets a connection object and attempts to cancel any ongoing queries.
+    #     """
+    #     # ## Example ##
+    #     # tid = connection.handle.transaction_id()
+    #     # sql = "select cancel_transaction({})".format(tid)
+    #     # logger.debug("Cancelling query "{}" ({})".format(connection_name, pid))
+    #     # _, cursor = self.add_query(sql, "master")
+    #     # res = cursor.fetchone()
+    #     # logger.debug("Canceled query "{}": {}".format(connection_name, res))
+    #     pass

dbt-sqlserver-1.7.4/dbt/adapters/sqlserver/sql_server_credentials.py → dbt-sqlserver-1.8.0rc2/dbt/adapters/sqlserver/sqlserver_credentials.py

@@ -6,6 +6,11 @@ from dbt.adapters.fabric import FabricCredentials
 
 @dataclass
 class SQLServerCredentials(FabricCredentials):
+    """
+    Defines database specific credentials that get added to
+    profiles.yml to connect to new adapter
+    """
+
     port: Optional[int] = 1433
     authentication: Optional[str] = "sql"
 

dbt-sqlserver-1.8.0rc2/dbt/adapters/sqlserver/sqlserver_relation.py

@@ -0,0 +1,51 @@
+from dataclasses import dataclass, field
+from typing import Optional, Type
+
+from dbt.adapters.base.relation import BaseRelation
+from dbt.adapters.utils import classproperty
+from dbt_common.exceptions import DbtRuntimeError
+
+from dbt.adapters.sqlserver.relation_configs import (
+    MAX_CHARACTERS_IN_IDENTIFIER,
+    SQLServerIncludePolicy,
+    SQLServerQuotePolicy,
+    SQLServerRelationType,
+)
+
+
+@dataclass(frozen=True, eq=False, repr=False)
+class SQLServerRelation(BaseRelation):
+    type: Optional[SQLServerRelationType] = None  # type: ignore
+    include_policy: SQLServerIncludePolicy = field(
+        default_factory=lambda: SQLServerIncludePolicy()
+    )
+    quote_policy: SQLServerQuotePolicy = field(default_factory=lambda: SQLServerQuotePolicy())
+
+    @classproperty
+    def get_relation_type(cls) -> Type[SQLServerRelationType]:
+        return SQLServerRelationType
+
+    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) {self._render_limited_alias()}"
+        else:
+            return f"(select TOP {self.limit} * from {rendered}) {self._render_limited_alias()}"
+
+    def __post_init__(self):
+        # Check for length of Redshift table/view names.
+        # Check self.type to exclude test relation identifiers
+        if (
+            self.identifier is not None
+            and self.type is not None
+            and len(self.identifier) > MAX_CHARACTERS_IN_IDENTIFIER
+        ):
+            raise DbtRuntimeError(
+                f"Relation name '{self.identifier}' "
+                f"is longer than {MAX_CHARACTERS_IN_IDENTIFIER} characters"
+            )
+
+    def relation_max_name_length(self):
+        return MAX_CHARACTERS_IN_IDENTIFIER

{dbt-sqlserver-1.7.4 → dbt-sqlserver-1.8.0rc2}/dbt/include/sqlserver/dbt_project.yml

@@ -1,6 +1,5 @@
 name: dbt_sqlserver
-version: 1.0
-
+version: 1.8.0
 config-version: 2
 
 macro-paths: ["macros"]

dbt-sqlserver-1.8.0rc2/dbt/include/sqlserver/macros/adapter/columns.sql

@@ -0,0 +1,25 @@
+{% macro sqlserver__alter_column_type(relation, column_name, new_column_type) %}
+
+    {%- set tmp_column = column_name + "__dbt_alter" -%}
+    {% set alter_column_type %}
+        alter {{ relation.type }} {{ relation }} add "{{ tmp_column }}" {{ new_column_type }};
+    {%- endset %}
+
+    {% set update_column %}
+        update {{ relation }} set "{{ tmp_column }}" = "{{ column_name }}";
+    {%- endset %}
+
+    {% set drop_column %}
+        alter {{ relation.type }} {{ relation }} drop column "{{ column_name }}";
+    {%- endset %}
+
+    {% set rename_column %}
+        exec sp_rename '{{ relation | replace('"', '') }}.{{ tmp_column }}', '{{ column_name }}', 'column'
+    {%- endset %}
+
+    {% do run_query(alter_column_type) %}
+    {% do run_query(update_column) %}
+    {% do run_query(drop_column) %}
+    {% do run_query(rename_column) %}
+
+{% endmacro %}

dbt-sqlserver-1.8.0rc2/dbt/include/sqlserver/macros/adapter/indexes.sql

@@ -0,0 +1,170 @@
+{% macro sqlserver__create_clustered_columnstore_index(relation) -%}
+    {%- set cci_name = (relation.schema ~ '_' ~ relation.identifier ~ '_cci') | replace(".", "") | replace(" ", "") -%}
+    {%- set relation_name = relation.schema ~ '_' ~ relation.identifier -%}
+    {%- set full_relation = '"' ~ relation.schema ~ '"."' ~ relation.identifier ~ '"' -%}
+    use [{{ relation.database }}];
+    if EXISTS (
+        SELECT *
+        FROM sys.indexes {{ information_schema_hints() }}
+        WHERE name = '{{cci_name}}'
+        AND object_id=object_id('{{relation_name}}')
+    )
+    DROP index {{full_relation}}.{{cci_name}}
+    CREATE CLUSTERED COLUMNSTORE INDEX {{cci_name}}
+    ON {{full_relation}}
+{% endmacro %}
+
+{% macro drop_xml_indexes() -%}
+    {{ log("Running drop_xml_indexes() macro...") }}
+
+    declare @drop_xml_indexes nvarchar(max);
+    select @drop_xml_indexes = (
+    select 'IF INDEXPROPERTY(' + CONVERT(VARCHAR(MAX), sys.tables.[object_id]) + ', ''' + sys.indexes.[name] + ''', ''IndexId'') IS NOT NULL DROP INDEX [' + sys.indexes.[name] + '] ON ' + '[' + SCHEMA_NAME(sys.tables.[schema_id]) + '].[' + OBJECT_NAME(sys.tables.[object_id]) + ']; '
+    from sys.indexes {{ information_schema_hints() }}
+    inner join sys.tables {{ information_schema_hints() }}
+    on sys.indexes.object_id = sys.tables.object_id
+    where sys.indexes.[name] is not null
+        and sys.indexes.type_desc = 'XML'
+        and sys.tables.[name] = '{{ this.table }}'
+    for xml path('')
+    ); exec sp_executesql @drop_xml_indexes;
+{%- endmacro %}
+
+
+{% macro drop_spatial_indexes() -%}
+    {# Altered from https://stackoverflow.com/q/1344401/10415173 #}
+    {# and https://stackoverflow.com/a/33785833/10415173         #}
+
+    {{ log("Running drop_spatial_indexes() macro...") }}
+
+    declare @drop_spatial_indexes nvarchar(max);
+    select @drop_spatial_indexes = (
+        select 'IF INDEXPROPERTY(' + CONVERT(VARCHAR(MAX), sys.tables.[object_id]) + ', ''' + sys.indexes.[name] + ''', ''IndexId'') IS NOT NULL DROP INDEX [' + sys.indexes.[name] + '] ON ' + '[' + SCHEMA_NAME(sys.tables.[schema_id]) + '].[' + OBJECT_NAME(sys.tables.[object_id]) + ']; '
+        from sys.indexes {{ information_schema_hints() }}
+        inner join sys.tables {{ information_schema_hints() }}
+        on sys.indexes.object_id = sys.tables.object_id
+        where sys.indexes.[name] is not null
+        and sys.indexes.type_desc = 'Spatial'
+        and sys.tables.[name] = '{{ this.table }}'
+        for xml path('')
+    ); exec sp_executesql @drop_spatial_indexes;
+{%- endmacro %}
+
+
+{% macro drop_fk_constraints() -%}
+    {# Altered from https://stackoverflow.com/q/1344401/10415173 #}
+
+    {{ log("Running drop_fk_constraints() macro...") }}
+
+    declare @drop_fk_constraints nvarchar(max);
+    select @drop_fk_constraints = (
+        select 'IF OBJECT_ID(''' + SCHEMA_NAME(CONVERT(VARCHAR(MAX), sys.foreign_keys.[schema_id])) + '.' + sys.foreign_keys.[name] + ''', ''F'') IS NOT NULL ALTER TABLE [' + SCHEMA_NAME(sys.foreign_keys.[schema_id]) + '].[' + OBJECT_NAME(sys.foreign_keys.[parent_object_id]) + '] DROP CONSTRAINT [' + sys.foreign_keys.[name]+ '];'
+        from sys.foreign_keys
+        inner join sys.tables on sys.foreign_keys.[referenced_object_id] = sys.tables.[object_id]
+        where sys.tables.[name] = '{{ this.table }}'
+        for xml path('')
+    ); exec sp_executesql @drop_fk_constraints;
+
+{%- endmacro %}
+
+
+{% macro drop_pk_constraints() -%}
+    {# Altered from https://stackoverflow.com/q/1344401/10415173 #}
+    {# and https://stackoverflow.com/a/33785833/10415173         #}
+
+    {{ drop_xml_indexes() }}
+
+    {{ drop_spatial_indexes() }}
+
+    {{ drop_fk_constraints() }}
+
+    {{ log("Running drop_pk_constraints() macro...") }}
+
+    declare @drop_pk_constraints nvarchar(max);
+    select @drop_pk_constraints = (
+        select 'IF INDEXPROPERTY(' + CONVERT(VARCHAR(MAX), sys.tables.[object_id]) + ', ''' + sys.indexes.[name] + ''', ''IndexId'') IS NOT NULL ALTER TABLE [' + SCHEMA_NAME(sys.tables.[schema_id]) + '].[' + sys.tables.[name] + '] DROP CONSTRAINT [' + sys.indexes.[name]+ '];'
+        from sys.indexes
+        inner join sys.tables on sys.indexes.[object_id] = sys.tables.[object_id]
+        where sys.indexes.is_primary_key = 1
+        and sys.tables.[name] = '{{ this.table }}'
+        for xml path('')
+    ); exec sp_executesql @drop_pk_constraints;
+
+{%- endmacro %}
+
+
+{% macro drop_all_indexes_on_table() -%}
+    {# Altered from https://stackoverflow.com/q/1344401/10415173 #}
+    {# and https://stackoverflow.com/a/33785833/10415173         #}
+
+    {{ drop_pk_constraints() }}
+
+    {{ log("Dropping remaining indexes...") }}
+
+    declare @drop_remaining_indexes_last nvarchar(max);
+    select @drop_remaining_indexes_last = (
+        select 'IF INDEXPROPERTY(' + CONVERT(VARCHAR(MAX), sys.tables.[object_id]) + ', ''' + sys.indexes.[name] + ''', ''IndexId'') IS NOT NULL DROP INDEX [' + sys.indexes.[name] + '] ON ' + '[' + SCHEMA_NAME(sys.tables.[schema_id]) + '].[' + OBJECT_NAME(sys.tables.[object_id]) + ']; '
+        from sys.indexes {{ information_schema_hints() }}
+        inner join sys.tables {{ information_schema_hints() }}
+        on sys.indexes.object_id = sys.tables.object_id
+        where sys.indexes.[name] is not null
+        and SCHEMA_NAME(sys.tables.schema_id) = '{{ this.schema }}'
+        and sys.tables.[name] = '{{ this.table }}'
+        for xml path('')
+    ); exec sp_executesql @drop_remaining_indexes_last;
+
+{%- endmacro %}
+
+
+{% macro create_clustered_index(columns, unique=False) -%}
+    {{ log("Creating clustered index...") }}
+
+    {% set idx_name = "clustered_" + local_md5(columns | join("_")) %}
+
+    if not exists(select *
+                    from sys.indexes {{ information_schema_hints() }}
+                    where name = '{{ idx_name }}'
+                    and object_id = OBJECT_ID('{{ this }}')
+    )
+    begin
+
+    create
+    {% if unique -%}
+    unique
+    {% endif %}
+    clustered index
+        {{ idx_name }}
+        on {{ this }} ({{ '[' + columns|join("], [") + ']' }})
+    end
+{%- endmacro %}
+
+
+{% macro create_nonclustered_index(columns, includes=False) %}
+
+    {{ log("Creating nonclustered index...") }}
+
+    {% if includes -%}
+        {% set idx_name = (
+            "nonclustered_"
+            + local_md5(columns | join("_"))
+            + "_incl_"
+            + local_md5(includes | join("_"))
+        ) %}
+    {% else -%}
+        {% set idx_name = "nonclustered_" + local_md5(columns | join("_")) %}
+    {% endif %}
+
+    if not exists(select *
+                    from sys.indexes {{ information_schema_hints() }}
+                    where name = '{{ idx_name }}'
+                    and object_id = OBJECT_ID('{{ this }}')
+    )
+    begin
+    create nonclustered index
+        {{ idx_name }}
+        on {{ this }} ({{ '[' + columns|join("], [") + ']' }})
+        {% if includes -%}
+            include ({{ '[' + includes|join("], [") + ']' }})
+        {% endif %}
+    end
+{% endmacro %}

dbt-sqlserver-1.8.0rc2/dbt/include/sqlserver/macros/adapter/metadata.sql

@@ -0,0 +1,5 @@
+{% macro apply_label() %}
+    {{ log (config.get('query_tag','dbt-sqlserver'))}}
+    {%- set query_label = config.get('query_tag','dbt-sqlserver') -%}
+    OPTION (LABEL = '{{query_label}}');
+{% endmacro %}

dbt-sqlserver-1.8.0rc2/dbt/include/sqlserver/macros/adapter/schemas.sql

@@ -0,0 +1,5 @@
+
+{% macro sqlserver__drop_schema_named(schema_name) %}
+  {% set schema_relation = api.Relation.create(schema=schema_name) %}
+  {{ adapter.drop_schema(schema_relation) }}
+{% endmacro %}

dbt-sqlserver-1.8.0rc2/dbt/include/sqlserver/macros/adapter/validate_sql.sql

@@ -0,0 +1,6 @@
+{% macro sqlserver__validate_sql(sql) -%}
+  {% call statement('validate_sql') -%}
+    {{ sql }}
+  {% endcall %}
+  {{ return(load_result('validate_sql')) }}
+{% endmacro %}