diff --git a/.github/ISSUE_TEMPLATE/dependabot.yml b/.github/ISSUE_TEMPLATE/dependabot.yml
index 8a8c85b9f..2a6f34492 100644
--- a/.github/ISSUE_TEMPLATE/dependabot.yml
+++ b/.github/ISSUE_TEMPLATE/dependabot.yml
@@ -5,4 +5,4 @@ updates:
     directory: "/"
     schedule:
       interval: "daily"
-    rebase-strategy: "disabled"
\ No newline at end of file
+    rebase-strategy: "disabled"
diff --git a/.github/ISSUE_TEMPLATE/release.md b/.github/ISSUE_TEMPLATE/release.md
index 4de49ebfe..0a1f364e0 100644
--- a/.github/ISSUE_TEMPLATE/release.md
+++ b/.github/ISSUE_TEMPLATE/release.md
@@ -7,4 +7,4 @@ assignees: ''
 
 ---
 
-### TBD
\ No newline at end of file
+### TBD
diff --git a/.github/pull_request_template.md b/.github/pull_request_template.md
index ab7b96bcc..4406822c1 100644
--- a/.github/pull_request_template.md
+++ b/.github/pull_request_template.md
@@ -4,7 +4,7 @@ Resolves #
 
 <!---
   Include the number of the issue addressed by this PR above if applicable.
-  
+
   Example:
     resolves #1234
 
diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml
index 6780be557..289057084 100644
--- a/.github/workflows/main.yml
+++ b/.github/workflows/main.yml
@@ -209,7 +209,7 @@ jobs:
           find ./dist/*.whl -maxdepth 1 -type f | xargs python -m pip install --force-reinstall --find-links=dist/
       - name: Install dbt-core
         run: |
-          python -m pip install dbt-core==1.8.0-b1
+          python -m pip install dbt-core==1.8.0rc2
       - name: Check wheel distributions
         run: |
           dbt --version
diff --git a/.gitignore b/.gitignore
index dfd1690fa..3d42d669e 100644
--- a/.gitignore
+++ b/.gitignore
@@ -18,4 +18,4 @@ test.env
 logs/
 .venv*
 *.sublime*
-.python-version
\ No newline at end of file
+.python-version
diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
new file mode 100644
index 000000000..d9c4167da
--- /dev/null
+++ b/.pre-commit-config.yaml
@@ -0,0 +1,20 @@
+# See https://pre-commit.com for more information
+# See https://pre-commit.com/hooks.html for more hooks
+repos:
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v3.2.0
+    hooks:
+      - id: trailing-whitespace
+      - id: end-of-file-fixer
+      - id: check-yaml
+      - id: check-added-large-files
+  - repo: https://github.com/psf/black-pre-commit-mirror
+    rev: 22.12.0
+    hooks:
+      - id: black
+        language_version: python3.11
+        args: [--config, black.ini]
+  - repo: https://github.com/asottile/reorder-python-imports
+    rev: v3.12.0
+    hooks:
+      - id: reorder-python-imports
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 7d5b192d1..54fff2830 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,18 +1,43 @@
-## dbt-databricks 1.8.0 (TBD)
+## dbt-databricks 2.0.0 (TBD)
 
 ### Features
 
 - Support `on_config_change` for materialized views, expand the supported config options ([536](https://github.com/databricks/dbt-databricks/pull/536)))
 - Support `on_config_change` for streaming tables, expand the supported config options ([569](https://github.com/databricks/dbt-databricks/pull/569)))
 - Support insert overwrite on SQL Warehouses ([623](https://github.com/databricks/dbt-databricks/pull/623))
+- Support Databricks tags for tables/views/incrementals ([631](https://github.com/databricks/dbt-databricks/pull/631))
 
 ### Under the Hood
 
 - Upgrade databricks-sql-connector to 3.1.0 ([593](https://github.com/databricks/dbt-databricks/pull/593))
 - Migrate to decoupled architecture ([596](https://github.com/databricks/dbt-databricks/pull/596))
 - Finish migrating integration tests ([623](https://github.com/databricks/dbt-databricks/pull/623))
+- Streamline the process of determining materialization types ([655](https://github.com/databricks/dbt-databricks/pull/655))
+- Improve catalog performance by getting column description from project for UC ([658](https://github.com/databricks/dbt-databricks/pull/658))
 
-## dbt-databricks 1.7.11 (TBD)
+## dbt-databricks 1.7.14 (May 1, 2024)
+
+### Fixes
+
+- Auth headers should now evaluate at call time ([648](https://github.com/databricks/dbt-databricks/pull/648))
+- User-configurable OAuth Scopes (currently limited to AWS) (thanks @stevenayers!) ([641](https://github.com/databricks/dbt-databricks/pull/641))
+
+### Under the hood
+
+- Reduce default idle limit for connection reuse to 60s and start organizing event logging ([648](https://github.com/databricks/dbt-databricks/pull/648))
+
+## dbt-databricks 1.7.13 (April 8, 2024)
+
+### Features
+
+- Apply tblproperties to python models (using alter table) ([633](https://github.com/databricks/dbt-databricks/pull/633))
+- Make OAuth redirect url configurable (thanks @johnsequeira-paradigm for the inspiration!) ([635]https://github.com/databricks/dbt-databricks/pull/635)
+
+### Fixes
+
+- Up default socket timeout to 10 minutes
+
+## dbt-databricks 1.7.11 (Mar 26, 2024)
 
 ### Fixes
 
diff --git a/CONTRIBUTING.MD b/CONTRIBUTING.MD
index 1b3f09ca9..46c86437e 100644
--- a/CONTRIBUTING.MD
+++ b/CONTRIBUTING.MD
@@ -5,6 +5,7 @@ We happily welcome contributions to the `dbt-databricks` package. We use [GitHub
 Contributions are licensed on a license-in/license-out basis.
 
 ## Communication
+
 Before starting work on a major feature, please reach out to us via GitHub, Slack, email, etc. We will make sure no one else is already working on it and ask you to open a GitHub issue. A "major feature" is defined as any change that is > 100 LOC altered (not including tests), or changes any user-facing behavior.
 
 We will use the GitHub issue to discuss the feature and come to agreement. This is to prevent your time being wasted, as well as ours. The GitHub review process for major features is also important so that organizations with commit access can come to agreement on design.
@@ -18,9 +19,8 @@ If it is appropriate to write a design document, the document must be hosted eit
 1. [Run the unit tests](#unit-tests) (and the [integration tests](#functional--integration-tests) if you [can](#please-test-what-you-can))
 1. [Sign your commits](#sign-your-work)
 1. [Open a pull request](#pull-request-review-process)
-    - Answer the PR template questions as best as you can
-    - _Recommended: [Allow edits from Maintainers]_
-
+   - Answer the PR template questions as best as you can
+   - _Recommended: [Allow edits from Maintainers]_
 
 ## Pull request review process
 
@@ -28,11 +28,11 @@ dbt-databricks uses a **two-step review process** to merge PRs to `main`. We fir
 
 > **Note:** When you create a pull request we recommend that you _[Allow Edits from Maintainers]_. This smooths our two-step process and also lets your reviewer easily commit minor fixes or changes.
 
-A dbt-databricks maintainer will review your PR and may suggest changes for style and clarity, or they may request that you add unit or integration tests. 
+A dbt-databricks maintainer will review your PR and may suggest changes for style and clarity, or they may request that you add unit or integration tests.
 
 Once your patch is approved, a maintainer will create a staging branch and either you or the maintainer (if you allowed edits from maintainers) will change the base branch of your PR to the staging branch. Then a maintainer will squash and merge the PR into the staging branch.
 
-dbt-databricks uses staging branches to run our full matrix of functional and integration tests via Github Actions. This extra step is required for security because GH Action workflows that run on pull requests from forks can't access our testing Databricks workspace. 
+dbt-databricks uses staging branches to run our full matrix of functional and integration tests via Github Actions. This extra step is required for security because GH Action workflows that run on pull requests from forks can't access our testing Databricks workspace.
 
 If the functional or integration tests fail as a result of your change, a maintainer will work with you to fix it _on your fork_ and then repeat this step.
 
@@ -58,7 +58,10 @@ tox -e linter
 
 To simplify reviews you can commit any format changes in a separate commit.
 
+Alternatively, [install pre-commit hooks](https://pre-commit.com/#3-install-the-git-hook-scripts) and the linting will be run automatically prior to accepting your commit.
+
 ## Sign your work
+
 The sign-off is a simple line at the end of the explanation for the patch. Your signature certifies that you wrote the patch or otherwise have the right to pass it on as an open-source patch. The rules are pretty simple: if you can certify the below (from developercertificate.org):
 
 ```
@@ -110,7 +113,6 @@ Use your real name (sorry, no pseudonyms or anonymous contributions.)
 
 If you set your `user.name` and `user.email` git configs, you can sign your commit automatically with `git commit -s`.
 
-
 ## Unit tests
 
 Unit tests do not require a Databricks account. Please confirm that your pull request passes our unit test suite before opening a pull request.
@@ -119,16 +121,16 @@ Unit tests do not require a Databricks account. Please confirm that your pull re
 tox -e unit
 ```
 
-## Functional & Integration Tests
+## Functional Tests
 
-Functional and integration tests require a Databricks account with access to a workspace containing four compute resources. These four comprise a matrix of multi-purpose cluster vs SQL warehouse with and without Unity Catalog enabled. The `tox` commands to run each set of these tests appear below:
+Functional tests require a Databricks account with access to a workspace containing three specific compute resources as detailed below.
+The `tox` commands to run each set of these tests appear below:
 
-|Compute Type |Unity Catalog |Command|
-|-|-|-|
-|SQL warehouse| Yes | `tox -e integration-databricks-uc-sql-endpoint`  |
-|SQL warehouse| No | `tox -e integration-databricks-sql-endpoint` |
-|Multi-purpose| Yes |  `tox -e integration-databricks-uc-cluster` |
-|Multi-Purpose| No | `tox -e integration-databricks-cluster` |
+| Compute Type        | Unity Catalog | Command                                         |
+| ------------------- | ------------- | ----------------------------------------------- |
+| SQL Warehouse       | Yes           | `tox -e integration-databricks-uc-sql-endpoint` |
+| All Purpose Cluster | Yes           | `tox -e integration-databricks-uc-cluster`      |
+| All Purpose         | No            | `tox -e integration-databricks-cluster`         |
 
 These tests are configured with environment variables that `tox` reads from a file called [test.env](/test.env.example) which you can copy from the example:
 
@@ -136,14 +138,13 @@ These tests are configured with environment variables that `tox` reads from a fi
 cp test.env.example test.env
 ```
 
-Update `test.env` with the relevant HTTP paths and tokens. 
-
+Update `test.env` with the relevant HTTP paths and tokens.
 
 ### Please test what you can
-We understand that not every contributor will have all four types of compute resources in their Databricks workspace. For this reason, once a change has been reviewed and merged into a staging branch, we will run the full matrix of tests against our testing workspace at our expense (see the [pull request review process](#pull-request-review-process) for more detail).
-
-That said, we ask that you include integration tests where relevant and that you indicate in your pull request description the environment type(s) you tested the change against.
 
+We understand that not every contributor will have all three types of compute resources in their Databricks workspace.
+For this reason, once a change has been reviewed and merged into a staging branch, we will run the full matrix of tests against our testing workspace at our expense (see the [pull request review process](#pull-request-review-process) for more detail).
 
+That said, we ask that you include integration tests where relevant and that you indicate in your pull request description the environment type(s) you tested the change against.
 
-[Allow Edits from Maintainers]: https://docs.github.com/en/pull-requests/collaborating-with-pull-requests/working-with-forks/allowing-changes-to-a-pull-request-branch-created-from-a-fork
\ No newline at end of file
+[Allow Edits from Maintainers]: https://docs.github.com/en/pull-requests/collaborating-with-pull-requests/working-with-forks/allowing-changes-to-a-pull-request-branch-created-from-a-fork
diff --git a/MANIFEST.in b/MANIFEST.in
index 78412d5b8..cfbc714ed 100644
--- a/MANIFEST.in
+++ b/MANIFEST.in
@@ -1 +1 @@
-recursive-include dbt/include *.sql *.yml *.md
\ No newline at end of file
+recursive-include dbt/include *.sql *.yml *.md
diff --git a/dbt/adapters/databricks/__init__.py b/dbt/adapters/databricks/__init__.py
index 89add168f..76392f7f4 100644
--- a/dbt/adapters/databricks/__init__.py
+++ b/dbt/adapters/databricks/__init__.py
@@ -1,10 +1,9 @@
-from dbt.adapters.databricks.connections import DatabricksConnectionManager  # noqa
-from dbt.adapters.databricks.connections import DatabricksCredentials
-from dbt.adapters.databricks.relation import DatabricksRelation  # noqa
+from dbt.adapters.base import AdapterPlugin
 from dbt.adapters.databricks.column import DatabricksColumn  # noqa
+from dbt.adapters.databricks.connections import DatabricksConnectionManager  # noqa
+from dbt.adapters.databricks.credentials import DatabricksCredentials
 from dbt.adapters.databricks.impl import DatabricksAdapter
-
-from dbt.adapters.base import AdapterPlugin
+from dbt.adapters.databricks.relation import DatabricksRelation  # noqa
 from dbt.include import databricks
 
 Plugin = AdapterPlugin(
diff --git a/dbt/adapters/databricks/__version__.py b/dbt/adapters/databricks/__version__.py
index 3d68fde3a..82253f3af 100644
--- a/dbt/adapters/databricks/__version__.py
+++ b/dbt/adapters/databricks/__version__.py
@@ -1 +1 @@
-version: str = "1.8.0b2"
+version: str = "2.0.0rc1"
diff --git a/dbt/adapters/databricks/auth.py b/dbt/adapters/databricks/auth.py
index 4d73fcc3f..51d894e05 100644
--- a/dbt/adapters/databricks/auth.py
+++ b/dbt/adapters/databricks/auth.py
@@ -1,7 +1,16 @@
-from typing import Any, Dict, Optional
-from databricks.sdk.oauth import ClientCredentials, Token
-from databricks.sdk.core import CredentialsProvider, HeaderFactory, Config, credentials_provider
+from typing import Any
+from typing import Dict
+from typing import Optional
+
+from databricks.sdk.core import Config
+from databricks.sdk.core import credentials_provider
+from databricks.sdk.core import CredentialsProvider
+from databricks.sdk.core import HeaderFactory
+from databricks.sdk.oauth import ClientCredentials
+from databricks.sdk.oauth import Token
 from databricks.sdk.oauth import TokenSource
+from requests import PreparedRequest
+from requests.auth import AuthBase
 
 
 class token_auth(CredentialsProvider):
@@ -77,3 +86,21 @@ def inner() -> Dict[str, str]:
             return {"Authorization": f"{token.token_type} {token.access_token}"}
 
         return inner
+
+
+class BearerAuth(AuthBase):
+    """This mix-in is passed to our requests Session to explicitly
+    use the bearer authentication method.
+
+    Without this, a local .netrc file in the user's home directory
+    will override the auth headers provided by our header_factory.
+
+    More details in issue #337.
+    """
+
+    def __init__(self, header_factory: HeaderFactory):
+        self.header_factory = header_factory
+
+    def __call__(self, r: PreparedRequest) -> PreparedRequest:
+        r.headers.update(**self.header_factory())
+        return r
diff --git a/dbt/adapters/databricks/column.py b/dbt/adapters/databricks/column.py
index c0e4367c9..45108a54a 100644
--- a/dbt/adapters/databricks/column.py
+++ b/dbt/adapters/databricks/column.py
@@ -1,5 +1,7 @@
 from dataclasses import dataclass
-from typing import ClassVar, Dict, Optional
+from typing import ClassVar
+from typing import Dict
+from typing import Optional
 
 from dbt.adapters.spark.column import SparkColumn
 
diff --git a/dbt/adapters/databricks/connections.py b/dbt/adapters/databricks/connections.py
index e0aff86b1..4c3ad2316 100644
--- a/dbt/adapters/databricks/connections.py
+++ b/dbt/adapters/databricks/connections.py
@@ -1,515 +1,100 @@
-import json
-from multiprocessing.context import SpawnContext
-import uuid
-import logging
-import warnings
-from contextlib import contextmanager
-from dataclasses import dataclass
 import decimal
-import itertools
 import os
 import re
 import sys
-import threading
 import time
-from threading import get_ident
-from typing import (
-    Any,
-    Callable,
-    Dict,
-    Iterable,
-    Iterator,
-    List,
-    Optional,
-    Sequence,
-    Tuple,
-    cast,
-    Union,
-    Hashable,
-)
+import uuid
+import warnings
+from contextlib import contextmanager
+from dataclasses import dataclass
+from multiprocessing.context import SpawnContext
 from numbers import Number
+from threading import get_ident
+from typing import Any
+from typing import Callable
+from typing import cast
+from typing import Dict
+from typing import Hashable
+from typing import Iterator
+from typing import List
+from typing import Optional
+from typing import Sequence
+from typing import Tuple
 
+import databricks.sql as dbsql
 from agate import Table
-
+from databricks.sql.client import Connection as DatabricksSQLConnection
+from databricks.sql.client import Cursor as DatabricksSQLCursor
+from databricks.sql.exc import Error
 from dbt.adapters.base.query_headers import MacroQueryStringSetter
+from dbt.adapters.contracts.connection import AdapterRequiredConfig
+from dbt.adapters.contracts.connection import AdapterResponse
+from dbt.adapters.contracts.connection import Connection
+from dbt.adapters.contracts.connection import ConnectionState
+from dbt.adapters.contracts.connection import DEFAULT_QUERY_COMMENT
+from dbt.adapters.contracts.connection import Identifier
+from dbt.adapters.contracts.connection import LazyHandle
+from dbt.adapters.databricks.__version__ import version as __version__
+from dbt.adapters.databricks.auth import BearerAuth
+from dbt.adapters.databricks.credentials import DatabricksCredentials
+from dbt.adapters.databricks.credentials import TCredentialProvider
+from dbt.adapters.databricks.events.connection_events import ConnectionAcquire
+from dbt.adapters.databricks.events.connection_events import ConnectionCancel
+from dbt.adapters.databricks.events.connection_events import ConnectionCancelError
+from dbt.adapters.databricks.events.connection_events import ConnectionClose
+from dbt.adapters.databricks.events.connection_events import ConnectionCloseError
+from dbt.adapters.databricks.events.connection_events import ConnectionCreate
+from dbt.adapters.databricks.events.connection_events import ConnectionCreated
+from dbt.adapters.databricks.events.connection_events import ConnectionCreateError
+from dbt.adapters.databricks.events.connection_events import ConnectionIdleCheck
+from dbt.adapters.databricks.events.connection_events import ConnectionIdleClose
+from dbt.adapters.databricks.events.connection_events import ConnectionRelease
+from dbt.adapters.databricks.events.connection_events import ConnectionReset
+from dbt.adapters.databricks.events.connection_events import ConnectionRetrieve
+from dbt.adapters.databricks.events.connection_events import ConnectionReuse
+from dbt.adapters.databricks.events.cursor_events import CursorCancel
+from dbt.adapters.databricks.events.cursor_events import CursorCancelError
+from dbt.adapters.databricks.events.cursor_events import CursorClose
+from dbt.adapters.databricks.events.cursor_events import CursorCloseError
+from dbt.adapters.databricks.events.cursor_events import CursorCreate
+from dbt.adapters.databricks.events.other_events import QueryError
+from dbt.adapters.databricks.events.pipeline_events import PipelineRefresh
+from dbt.adapters.databricks.events.pipeline_events import PipelineRefreshError
+from dbt.adapters.databricks.logging import logger
+from dbt.adapters.databricks.utils import redact_credentials
+from dbt.adapters.events.types import ConnectionClosedInCleanup
+from dbt.adapters.events.types import ConnectionLeftOpenInCleanup
+from dbt.adapters.events.types import ConnectionReused
+from dbt.adapters.events.types import ConnectionUsed
+from dbt.adapters.events.types import NewConnection
+from dbt.adapters.events.types import SQLQuery
+from dbt.adapters.events.types import SQLQueryStatus
 from dbt.adapters.spark.connections import SparkConnectionManager
 from dbt_common.clients import agate_helper
-from dbt.adapters.contracts.connection import (
-    AdapterResponse,
-    AdapterRequiredConfig,
-    Connection,
-    ConnectionState,
-    Credentials,
-    DEFAULT_QUERY_COMMENT,
-    Identifier,
-    LazyHandle,
-)
-from dbt.adapters.events.types import (
-    NewConnection,
-    ConnectionReused,
-    ConnectionUsed,
-    ConnectionLeftOpenInCleanup,
-    ConnectionClosedInCleanup,
-    SQLQuery,
-    SQLQueryStatus,
-)
-
-from dbt.adapters.events.logging import AdapterLogger
 from dbt_common.events.contextvars import get_node_info
 from dbt_common.events.functions import fire_event
+from dbt_common.exceptions import DbtInternalError
+from dbt_common.exceptions import DbtRuntimeError
 from dbt_common.utils import cast_to_str
-
-import databricks.sql as dbsql
-from databricks.sql.client import (
-    Connection as DatabricksSQLConnection,
-    Cursor as DatabricksSQLCursor,
-)
-from databricks.sql.exc import Error
-
-from dbt.adapters.databricks.__version__ import version as __version__
-from dbt.adapters.databricks.utils import redact_credentials
-
-from databricks.sdk.core import CredentialsProvider
-from databricks.sdk.oauth import OAuthClient, SessionCredentials
-from dbt.adapters.databricks.auth import token_auth, m2m_auth
-
-from requests.auth import AuthBase
-from requests import PreparedRequest
-from databricks.sdk.core import HeaderFactory
-
-import keyring
 from requests import Session
-from dbt_common.exceptions import (
-    DbtValidationError,
-    DbtConfigError,
-    DbtRuntimeError,
-    DbtInternalError,
-)
 
 
 mv_refresh_regex = re.compile(r"refresh\s+materialized\s+view\s+([`\w.]+)", re.IGNORECASE)
 st_refresh_regex = re.compile(
     r"create\s+or\s+refresh\s+streaming\s+table\s+([`\w.]+)", re.IGNORECASE
 )
-logger = AdapterLogger("Databricks")
 
 
-TCredentialProvider = Union[CredentialsProvider, SessionCredentials]
-
-
-class DbtCoreHandler(logging.Handler):
-    def __init__(self, level: Union[str, int], dbt_logger: AdapterLogger):
-        super().__init__(level=level)
-        self.logger = dbt_logger
-
-    def emit(self, record: logging.LogRecord) -> None:
-        # record.levelname will be debug, info, warning, error, or critical
-        # these map 1-to-1 with methods of the AdapterLogger
-        log_func = getattr(self.logger, record.levelname.lower())
-        log_func(record.msg)
-
-
-dbt_adapter_logger = AdapterLogger("databricks-sql-connector")
-
-pysql_logger = logging.getLogger("databricks.sql")
-pysql_logger_level = os.environ.get("DBT_DATABRICKS_CONNECTOR_LOG_LEVEL", "WARN").upper()
-pysql_logger.setLevel(pysql_logger_level)
-
-pysql_handler = DbtCoreHandler(dbt_logger=dbt_adapter_logger, level=pysql_logger_level)
-pysql_logger.addHandler(pysql_handler)
-
-
-CATALOG_KEY_IN_SESSION_PROPERTIES = "databricks.catalog"
 DBR_VERSION_REGEX = re.compile(r"([1-9][0-9]*)\.(x|0|[1-9][0-9]*)")
-DBT_DATABRICKS_INVOCATION_ENV = "DBT_DATABRICKS_INVOCATION_ENV"
-DBT_DATABRICKS_INVOCATION_ENV_REGEX = re.compile("^[A-z0-9\\-]+$")
-EXTRACT_CLUSTER_ID_FROM_HTTP_PATH_REGEX = re.compile(r"/?sql/protocolv1/o/\d+/(.*)")
-DBT_DATABRICKS_HTTP_SESSION_HEADERS = "DBT_DATABRICKS_HTTP_SESSION_HEADERS"
 
-REDIRECT_URL = "http://localhost:8020"
-CLIENT_ID = "dbt-databricks"
-SCOPES = ["all-apis", "offline_access"]
-MAX_NT_PASSWORD_SIZE = 1280
 
 # toggle for session managements that minimizes the number of sessions opened/closed
 USE_LONG_SESSIONS = os.getenv("DBT_DATABRICKS_LONG_SESSIONS", "True").upper() == "TRUE"
 
 # Number of idle seconds before a connection is automatically closed. Only applicable if
 # USE_LONG_SESSIONS is true.
-DEFAULT_MAX_IDLE_TIME = 600
-
-
-class BearerAuth(AuthBase):
-    """This mix-in is passed to our requests Session to explicitly
-    use the bearer authentication method.
-
-    Without this, a local .netrc file in the user's home directory
-    will override the auth headers provided by our header_factory.
-
-    More details in issue #337.
-    """
-
-    def __init__(self, headers: HeaderFactory):
-        self.headers = headers()
-
-    def __call__(self, r: PreparedRequest) -> PreparedRequest:
-        r.headers.update(**self.headers)
-        return r
-
-
-@dataclass
-class DatabricksCredentials(Credentials):
-    database: Optional[str] = None  # type: ignore[assignment]
-    schema: Optional[str] = None  # type: ignore[assignment]
-    host: Optional[str] = None
-    http_path: Optional[str] = None
-    token: Optional[str] = None
-    client_id: Optional[str] = None
-    client_secret: Optional[str] = None
-    session_properties: Optional[Dict[str, Any]] = None
-    connection_parameters: Optional[Dict[str, Any]] = None
-    auth_type: Optional[str] = None
-
-    # Named compute resources specified in the profile. Used for
-    # creating a connection when a model specifies a compute resource.
-    compute: Optional[Dict[str, Any]] = None
-
-    connect_retries: int = 1
-    connect_timeout: Optional[int] = None
-    retry_all: bool = False
-    connect_max_idle: Optional[int] = None
-
-    _credentials_provider: Optional[Dict[str, Any]] = None
-    _lock = threading.Lock()  # to avoid concurrent auth
-
-    _ALIASES = {
-        "catalog": "database",
-        "target_catalog": "target_database",
-    }
-
-    @classmethod
-    def __pre_deserialize__(cls, data: Dict[Any, Any]) -> Dict[Any, Any]:
-        data = super().__pre_deserialize__(data)
-        if "database" not in data:
-            data["database"] = None
-        return data
-
-    def __post_init__(self) -> None:
-        if "." in (self.schema or ""):
-            raise DbtValidationError(
-                f"The schema should not contain '.': {self.schema}\n"
-                "If you are trying to set a catalog, please use `catalog` instead.\n"
-            )
-
-        session_properties = self.session_properties or {}
-        if CATALOG_KEY_IN_SESSION_PROPERTIES in session_properties:
-            if self.database is None:
-                self.database = session_properties[CATALOG_KEY_IN_SESSION_PROPERTIES]
-                del session_properties[CATALOG_KEY_IN_SESSION_PROPERTIES]
-            else:
-                raise DbtValidationError(
-                    f"Got duplicate keys: (`{CATALOG_KEY_IN_SESSION_PROPERTIES}` "
-                    'in session_properties) all map to "database"'
-                )
-        self.session_properties = session_properties
-
-        if self.database is not None:
-            database = self.database.strip()
-            if not database:
-                raise DbtValidationError(f"Invalid catalog name : `{self.database}`.")
-            self.database = database
-        else:
-            self.database = "hive_metastore"
-
-        connection_parameters = self.connection_parameters or {}
-        for key in (
-            "server_hostname",
-            "http_path",
-            "access_token",
-            "client_id",
-            "client_secret",
-            "session_configuration",
-            "catalog",
-            "schema",
-            "_user_agent_entry",
-        ):
-            if key in connection_parameters:
-                raise DbtValidationError(f"The connection parameter `{key}` is reserved.")
-        if "http_headers" in connection_parameters:
-            http_headers = connection_parameters["http_headers"]
-            if not isinstance(http_headers, dict) or any(
-                not isinstance(key, str) or not isinstance(value, str)
-                for key, value in http_headers.items()
-            ):
-                raise DbtValidationError(
-                    "The connection parameter `http_headers` should be dict of strings: "
-                    f"{http_headers}."
-                )
-        if "_socket_timeout" not in connection_parameters:
-            connection_parameters["_socket_timeout"] = 180
-        self.connection_parameters = connection_parameters
-
-    def validate_creds(self) -> None:
-        for key in ["host", "http_path"]:
-            if not getattr(self, key):
-                raise DbtConfigError(
-                    "The config '{}' is required to connect to Databricks".format(key)
-                )
-        if not self.token and self.auth_type != "oauth":
-            raise DbtConfigError(
-                ("The config `auth_type: oauth` is required when not using access token")
-            )
-
-        if not self.client_id and self.client_secret:
-            raise DbtConfigError(
-                (
-                    "The config 'client_id' is required to connect "
-                    "to Databricks when 'client_secret' is present"
-                )
-            )
-
-    @classmethod
-    def get_invocation_env(cls) -> Optional[str]:
-        invocation_env = os.environ.get(DBT_DATABRICKS_INVOCATION_ENV)
-        if invocation_env:
-            # Thrift doesn't allow nested () so we need to ensure
-            # that the passed user agent is valid.
-            if not DBT_DATABRICKS_INVOCATION_ENV_REGEX.search(invocation_env):
-                raise DbtValidationError(f"Invalid invocation environment: {invocation_env}")
-        return invocation_env
-
-    @classmethod
-    def get_all_http_headers(cls, user_http_session_headers: Dict[str, str]) -> Dict[str, str]:
-        http_session_headers_str: Optional[str] = os.environ.get(
-            DBT_DATABRICKS_HTTP_SESSION_HEADERS
-        )
-
-        http_session_headers_dict: Dict[str, str] = (
-            {
-                k: v if isinstance(v, str) else json.dumps(v)
-                for k, v in json.loads(http_session_headers_str).items()
-            }
-            if http_session_headers_str is not None
-            else {}
-        )
-
-        intersect_http_header_keys = (
-            user_http_session_headers.keys() & http_session_headers_dict.keys()
-        )
-
-        if len(intersect_http_header_keys) > 0:
-            raise DbtValidationError(
-                f"Intersection with reserved http_headers in keys: {intersect_http_header_keys}"
-            )
-
-        http_session_headers_dict.update(user_http_session_headers)
-
-        return http_session_headers_dict
-
-    @property
-    def type(self) -> str:
-        return "databricks"
-
-    @property
-    def unique_field(self) -> str:
-        return cast(str, self.host)
-
-    def connection_info(self, *, with_aliases: bool = False) -> Iterable[Tuple[str, Any]]:
-        as_dict = self.to_dict(omit_none=False)
-        connection_keys = set(self._connection_keys(with_aliases=with_aliases))
-        aliases: List[str] = []
-        if with_aliases:
-            aliases = [k for k, v in self._ALIASES.items() if v in connection_keys]
-        for key in itertools.chain(self._connection_keys(with_aliases=with_aliases), aliases):
-            if key in as_dict:
-                yield key, as_dict[key]
-
-    def _connection_keys(self, *, with_aliases: bool = False) -> Tuple[str, ...]:
-        # Assuming `DatabricksCredentials.connection_info(self, *, with_aliases: bool = False)`
-        # is called from only:
-        #
-        # - `Profile` with `with_aliases=True`
-        # - `DebugTask` without `with_aliases` (`False` by default)
-        #
-        # Thus, if `with_aliases` is `True`, `DatabricksCredentials._connection_keys` should return
-        # the internal key names; otherwise it can use aliases to show in `dbt debug`.
-        connection_keys = ["host", "http_path", "schema"]
-        if with_aliases:
-            connection_keys.insert(2, "database")
-        elif self.database:
-            connection_keys.insert(2, "catalog")
-        if self.session_properties:
-            connection_keys.append("session_properties")
-        return tuple(connection_keys)
-
-    @classmethod
-    def extract_cluster_id(cls, http_path: str) -> Optional[str]:
-        m = EXTRACT_CLUSTER_ID_FROM_HTTP_PATH_REGEX.match(http_path)
-        if m:
-            return m.group(1).strip()
-        else:
-            return None
-
-    @property
-    def cluster_id(self) -> Optional[str]:
-        return self.extract_cluster_id(self.http_path)  # type: ignore[arg-type]
-
-    def authenticate(self, in_provider: Optional[TCredentialProvider]) -> TCredentialProvider:
-        self.validate_creds()
-        host: str = self.host or ""
-        if self._credentials_provider:
-            return self._provider_from_dict()  # type: ignore
-        if in_provider:
-            if isinstance(in_provider, m2m_auth) or isinstance(in_provider, token_auth):
-                self._credentials_provider = in_provider.as_dict()
-            return in_provider
-
-        provider: TCredentialProvider
-        # dbt will spin up multiple threads. This has to be sync. So lock here
-        self._lock.acquire()
-        try:
-            if self.token:
-                provider = token_auth(self.token)
-                self._credentials_provider = provider.as_dict()
-                return provider
-
-            if self.client_id and self.client_secret:
-                provider = m2m_auth(
-                    host=host,
-                    client_id=self.client_id or "",
-                    client_secret=self.client_secret or "",
-                )
-                self._credentials_provider = provider.as_dict()
-                return provider
-
-            oauth_client = OAuthClient(
-                host=host,
-                client_id=self.client_id if self.client_id else CLIENT_ID,
-                client_secret="",
-                redirect_url=REDIRECT_URL,
-                scopes=SCOPES,
-            )
-            # optional branch. Try and keep going if it does not work
-            try:
-                # try to get cached credentials
-                credsdict = self.get_sharded_password("dbt-databricks", host)
-
-                if credsdict:
-                    provider = SessionCredentials.from_dict(oauth_client, json.loads(credsdict))
-                    # if refresh token is expired, this will throw
-                    try:
-                        if provider.token().valid:
-                            return provider
-                    except Exception as e:
-                        logger.debug(e)
-                        # whatever it is, get rid of the cache
-                        self.delete_sharded_password("dbt-databricks", host)
-
-            # error with keyring. Maybe machine has no password persistency
-            except Exception as e:
-                logger.debug(e)
-                logger.info("could not retrieved saved token")
-
-            # no token, go fetch one
-            consent = oauth_client.initiate_consent()
-
-            provider = consent.launch_external_browser()
-            # save for later
-            self._credentials_provider = provider.as_dict()
-            try:
-                self.set_sharded_password(
-                    "dbt-databricks", host, json.dumps(self._credentials_provider)
-                )
-            # error with keyring. Maybe machine has no password persistency
-            except Exception as e:
-                logger.debug(e)
-                logger.info("could not save token")
-
-            return provider
-
-        finally:
-            self._lock.release()
-
-    def set_sharded_password(self, service_name: str, username: str, password: str) -> None:
-        max_size = MAX_NT_PASSWORD_SIZE
-
-        # if not Windows or "small" password, stick to the default
-        if os.name != "nt" or len(password) < max_size:
-            keyring.set_password(service_name, username, password)
-        else:
-            logger.debug(f"password is {len(password)} characters, sharding it.")
-
-            password_shards = [
-                password[i : i + max_size] for i in range(0, len(password), max_size)
-            ]
-            shard_info = {
-                "sharded_password": True,
-                "shard_count": len(password_shards),
-            }
-
-            # store the "shard info" as the "base" password
-            keyring.set_password(service_name, username, json.dumps(shard_info))
-            # then store all shards with the shard number as postfix
-            for i, s in enumerate(password_shards):
-                keyring.set_password(service_name, f"{username}__{i}", s)
-
-    def get_sharded_password(self, service_name: str, username: str) -> Optional[str]:
-        password = keyring.get_password(service_name, username)
-
-        # check for "shard info" stored as json
-        try:
-            password_as_dict = json.loads(str(password))
-            if password_as_dict.get("sharded_password"):
-                # if password was stored shared, reconstruct it
-                shard_count = int(password_as_dict.get("shard_count"))
-
-                password = ""
-                for i in range(shard_count):
-                    password += str(keyring.get_password(service_name, f"{username}__{i}"))
-        except ValueError:
-            pass
-
-        return password
-
-    def delete_sharded_password(self, service_name: str, username: str) -> None:
-        password = keyring.get_password(service_name, username)
-
-        # check for "shard info" stored as json. If so delete all shards
-        try:
-            password_as_dict = json.loads(str(password))
-            if password_as_dict.get("sharded_password"):
-                shard_count = int(password_as_dict.get("shard_count"))
-                for i in range(shard_count):
-                    keyring.delete_password(service_name, f"{username}__{i}")
-        except ValueError:
-            pass
-
-        # delete "base" password
-        keyring.delete_password(service_name, username)
-
-    def _provider_from_dict(self) -> Optional[TCredentialProvider]:
-        if self.token:
-            return token_auth.from_dict(self._credentials_provider)
-
-        if self.client_id and self.client_secret:
-            return m2m_auth.from_dict(
-                host=self.host or "",
-                client_id=self.client_id or "",
-                client_secret=self.client_secret or "",
-                raw=self._credentials_provider or {"token": {}},
-            )
-
-        oauth_client = OAuthClient(
-            host=self.host or "",
-            client_id=CLIENT_ID,
-            client_secret="",
-            redirect_url=REDIRECT_URL,
-            scopes=SCOPES,
-        )
-
-        return SessionCredentials.from_dict(
-            client=oauth_client, raw=self._credentials_provider or {"token": {}}
-        )
+# Updated when idle times of 180s were causing errors
+DEFAULT_MAX_IDLE_TIME = 60
 
 
 class DatabricksSQLConnectionWrapper:
@@ -537,6 +122,9 @@ def __init__(
 
     def cursor(self) -> "DatabricksSQLCursorWrapper":
         cursor = self._conn.cursor()
+
+        logger.debug(CursorCreate(cursor))
+
         self._cursors.append(cursor)
         return DatabricksSQLCursorWrapper(
             cursor,
@@ -545,21 +133,23 @@ def cursor(self) -> "DatabricksSQLCursorWrapper":
         )
 
     def cancel(self) -> None:
+        logger.debug(ConnectionCancel(self._conn))
+
         cursors: List[DatabricksSQLCursor] = self._cursors
 
         for cursor in cursors:
             try:
                 cursor.cancel()
             except Error as exc:
-                logger.debug("Exception while cancelling query: {}".format(exc))
-                _log_dbsql_errors(exc)
+                logger.warning(ConnectionCancelError(self._conn, exc))
 
     def close(self) -> None:
+        logger.debug(ConnectionClose(self._conn))
+
         try:
             self._conn.close()
         except Error as exc:
-            logger.debug("Exception while closing connection: {}".format(exc))
-            _log_dbsql_errors(exc)
+            logger.warning(ConnectionCloseError(self._conn, exc))
 
     def rollback(self, *args: Any, **kwargs: Any) -> None:
         logger.debug("NotImplemented: rollback")
@@ -572,7 +162,9 @@ def dbr_version(self) -> Tuple[int, int]:
             if self._is_cluster:
                 with self._conn.cursor() as cursor:
                     cursor.execute("SET spark.databricks.clusterUsageTags.sparkVersion")
-                    dbr_version: str = cursor.fetchone()[1]
+                    results = cursor.fetchone()
+                    if results:
+                        dbr_version: str = results[1]
 
                 m = DBR_VERSION_REGEX.search(dbr_version)
                 assert m, f"Unknown DBR version: {dbr_version}"
@@ -602,18 +194,20 @@ def __init__(self, cursor: DatabricksSQLCursor, creds: DatabricksCredentials, us
         self._user_agent = user_agent
 
     def cancel(self) -> None:
+        logger.debug(CursorCancel(self._cursor))
+
         try:
             self._cursor.cancel()
         except Error as exc:
-            logger.debug("Exception while cancelling query: {}".format(exc))
-            _log_dbsql_errors(exc)
+            logger.warning(CursorCancelError(self._cursor, exc))
 
     def close(self) -> None:
+        logger.debug(CursorClose(self._cursor))
+
         try:
             self._cursor.close()
         except Error as exc:
-            logger.debug("Exception while closing cursor: {}".format(exc))
-            _log_dbsql_errors(exc)
+            logger.warning(CursorCloseError(self._cursor, exc))
 
     def fetchall(self) -> Sequence[Tuple]:
         return self._cursor.fetchall()
@@ -652,8 +246,9 @@ def pollRefreshPipeline(
 
         stopped_states = ("COMPLETED", "FAILED", "CANCELED")
         host: str = self._creds.host or ""
-        headers = self._cursor.connection.thrift_backend._auth_provider._header_factory
-
+        headers = (
+            self._cursor.connection.thrift_backend._auth_provider._header_factory  # type: ignore
+        )
         session = Session()
         session.auth = BearerAuth(headers)
         session.headers = {"User-Agent": self._user_agent}
@@ -670,9 +265,7 @@ def pollRefreshPipeline(
         update_id = latest_update.get("update_id", "")
         prev_state = state
 
-        logger.info(
-            f"refreshing {model_name}, pipeline: {pipeline_id}, update: {update_id} {state}"
-        )
+        logger.info(PipelineRefresh(pipeline_id, update_id, model_name, str(state)))
 
         start = time.time()
         exceeded_timeout = False
@@ -694,16 +287,17 @@ def pollRefreshPipeline(
 
             state = update.get("state")
             if state != prev_state:
-                logger.info(
-                    f"refreshing {model_name}, pipeline: {pipeline_id}, update: {update_id} {state}"
-                )
+                logger.info(PipelineRefresh(pipeline_id, update_id, model_name, str(state)))
                 prev_state = state
 
             if state == "FAILED":
-                logger.error(f"pipeline {pipeline_id} update {update_id} failed")
-                msg = _get_update_error_msg(session, host, pipeline_id, update_id)
-                if msg:
-                    logger.error(msg)
+                logger.error(
+                    PipelineRefreshError(
+                        pipeline_id,
+                        update_id,
+                        _get_update_error_msg(session, host, pipeline_id, update_id),
+                    )
+                )
 
                 # another update may have been created due to retry_on_fail settings
                 # get the latest update and see if it is a new one
@@ -742,10 +336,10 @@ def hex_query_id(self) -> str:
 
         This UUID can be tied back to the Databricks query history API
         """
-
-        _as_hex = uuid.UUID(bytes=self._cursor.active_result_set.command_id.operationId.guid)
-
-        return str(_as_hex)
+        if self._cursor.active_result_set:
+            _as_hex = uuid.UUID(bytes=self._cursor.active_result_set.command_id.operationId.guid)
+            return str(_as_hex)
+        return ""
 
     @classmethod
     def _fix_binding(cls, value: Any) -> Any:
@@ -757,19 +351,7 @@ def _fix_binding(cls, value: Any) -> Any:
             return value
 
     @property
-    def description(
-        self,
-    ) -> Sequence[
-        Tuple[
-            str,
-            str,
-            Optional[int],
-            Optional[int],
-            Optional[int],
-            Optional[int],
-            Optional[bool],
-        ]
-    ]:
+    def description(self) -> Optional[List[Tuple]]:
         return self._cursor.description
 
     def schemas(self, catalog_name: str, schema_name: Optional[str] = None) -> None:
@@ -783,6 +365,8 @@ def tables(self, catalog_name: str, schema_name: str, table_name: Optional[str]
     def __del__(self) -> None:
         if self._cursor.open:
             # This should not happen. The cursor should explicitly be closed.
+            logger.debug(CursorClose(self._cursor))
+
             self._cursor.close()
             with warnings.catch_warnings():
                 warnings.simplefilter("always")
@@ -846,7 +430,7 @@ class DatabricksDBTConnection(Connection):
 
     def _acquire(self, query_header_context: Any) -> None:
         """Indicate that this connection is in use."""
-        self._log_usage(query_header_context)
+
         self.acquire_release_count += 1
         if self.last_used_time is None:
             self.last_used_time = time.time()
@@ -855,7 +439,11 @@ def _acquire(self, query_header_context: Any) -> None:
         else:
             self.language = None
 
-        self._log_info("_acquire")
+        logger.debug(
+            ConnectionAcquire(
+                str(self), query_header_context, self.compute_name, self.thread_identifier
+            )
+        )
 
     def _release(self) -> None:
         """Indicate that this connection is not in use."""
@@ -869,7 +457,7 @@ def _release(self) -> None:
         if self.acquire_release_count == 0 and self.language != "python":
             self.last_used_time = time.time()
 
-        self._log_info("_release")
+        logger.debug(ConnectionRelease(str(self)))
 
     def _get_idle_time(self) -> float:
         return 0 if self.last_used_time is None else time.time() - self.last_used_time
@@ -877,56 +465,27 @@ def _get_idle_time(self) -> float:
     def _idle_too_long(self) -> bool:
         return self.max_idle_time > 0 and self._get_idle_time() > self.max_idle_time
 
-    def _get_conn_info_str(self) -> str:
-        """Generate a string describing this connection."""
+    def __str__(self) -> str:
         return (
-            f"sess: {self.session_id}, name: {self.name}, "
-            f"idle: {self._get_idle_time()}s, acqrelcnt: {self.acquire_release_count}, "
-            f"lang: {self.language}, thrd: {self.thread_identifier}, "
-            f"cmpt: `{self.compute_name}`, lut: {self.last_used_time}"
+            f"DatabricksDBTConnection(id={id(self)}, session-id={self.session_id}, "
+            f"name={self.name}, idle-time={self._get_idle_time()}s, acquire-count="
+            f"{self.acquire_release_count}, language={self.language}, thread-identifier="
+            f"{self.thread_identifier}, compute-name={self.compute_name})"
         )
 
-    def _log_info(self, caller: Optional[str]) -> None:
-        logger.debug(f"conn: {id(self)}: {caller} {self._get_conn_info_str()}")
-
-    def _log_usage(self, query_header_context: Any) -> None:
-        if query_header_context:
-            # ResultNode *should* have relation_name attr, but we work around a core
-            # issue by checking.
-            relation_name = getattr(query_header_context, "relation_name", "[unknown]")
-            if not self.compute_name:
-                logger.debug(
-                    f"On thread {self.thread_identifier}: {relation_name} "
-                    "using default compute resource."
-                )
-            else:
-                logger.debug(
-                    f"On thread {self.thread_identifier}: {relation_name} "
-                    f"using compute resource '{self.compute_name}'."
-                )
-        else:
-            logger.debug(f"Thread {self.thread_identifier} using default compute resource.")
-
     def _reset_handle(self, open: Callable[[Connection], Connection]) -> None:
-        self._log_info("_reset_handle")
         self.handle = LazyHandle(open)
         self.session_id = None
         # Reset last_used_time to None because by refreshing this connection becomes associated
         # with a new session that hasn't been used yet.
         self.last_used_time = None
+        logger.debug(ConnectionReset(str(self)))
 
 
 class DatabricksConnectionManager(SparkConnectionManager):
     TYPE: str = "databricks"
     credentials_provider: Optional[TCredentialProvider] = None
 
-    def __init__(self, profile: AdapterRequiredConfig, mp_context: SpawnContext) -> None:
-        super().__init__(profile, mp_context)
-        if USE_LONG_SESSIONS:
-            self.threads_compute_connections: Dict[
-                Hashable, Dict[Hashable, DatabricksDBTConnection]
-            ] = {}
-
     def compare_dbr_version(self, major: int, minor: int) -> int:
         version = (major, minor)
 
@@ -945,13 +504,11 @@ def exception_handler(self, sql: str) -> Iterator[None]:
             yield
 
         except Error as exc:
-            logger.debug(f"Error while running:\n{log_sql}")
-            _log_dbsql_errors(exc)
+            logger.debug(QueryError(log_sql, exc))
             raise DbtRuntimeError(str(exc)) from exc
 
         except Exception as exc:
-            logger.debug(f"Error while running:\n{log_sql}")
-            logger.debug(exc)
+            logger.debug(QueryError(log_sql, exc))
             if len(exc.args) == 0:
                 raise
 
@@ -971,9 +528,6 @@ def set_connection_name(
         Creates a connection for this thread if one doesn't already
         exist, and will rename an existing connection."""
 
-        if USE_LONG_SESSIONS:
-            return self._get_compute_connection(name, query_header_context)
-
         conn_name: str = "master" if name is None else name
 
         # Get a connection for this thread
@@ -985,7 +539,7 @@ def set_connection_name(
 
         if conn is None:
             # Create a new connection
-            conn = Connection(
+            conn = DatabricksDBTConnection(
                 type=Identifier(self.TYPE),
                 name=conn_name,
                 state=ConnectionState.INIT,
@@ -1009,312 +563,83 @@ def set_connection_name(
 
         return conn
 
-    # override
-    def release(self) -> None:
-        if not USE_LONG_SESSIONS:
-            return super().release()
-
-        with self.lock:
-            conn = cast(Optional[DatabricksDBTConnection], self.get_if_exists())
-            if conn is None:
-                return
-
-        conn._release()
-
-    # override
-    @classmethod
-    def close(cls, connection: Connection) -> Connection:
-        if not USE_LONG_SESSIONS:
-            return super().close(connection)
+    def add_query(
+        self,
+        sql: str,
+        auto_begin: bool = True,
+        bindings: Optional[Any] = None,
+        abridge_sql_log: bool = False,
+        *,
+        close_cursor: bool = False,
+    ) -> Tuple[Connection, Any]:
+        connection = self.get_thread_connection()
+        if auto_begin and connection.transaction_open is False:
+            self.begin()
+        fire_event(ConnectionUsed(conn_type=self.TYPE, conn_name=cast_to_str(connection.name)))
 
-        try:
-            return super().close(connection)
-        except Exception as e:
-            logger.warning(f"ignoring error when closing connection: {e}")
-            connection.state = ConnectionState.CLOSED
-            return connection
+        with self.exception_handler(sql):
+            cursor: Optional[DatabricksSQLCursorWrapper] = None
+            try:
+                log_sql = redact_credentials(sql)
+                if abridge_sql_log:
+                    log_sql = "{}...".format(log_sql[:512])
 
-    # override
-    def cleanup_all(self) -> None:
-        if not USE_LONG_SESSIONS:
-            return super().cleanup_all()
+                fire_event(
+                    SQLQuery(
+                        conn_name=cast_to_str(connection.name),
+                        sql=log_sql,
+                        node_info=get_node_info(),
+                    )
+                )
 
-        with self.lock:
-            for thread_connections in self.threads_compute_connections.values():
-                for connection in thread_connections.values():
-                    if connection.acquire_release_count > 0:
-                        fire_event(
-                            ConnectionLeftOpenInCleanup(conn_name=cast_to_str(connection.name))
-                        )
-                    else:
-                        fire_event(
-                            ConnectionClosedInCleanup(conn_name=cast_to_str(connection.name))
-                        )
-                    self.close(connection)
+                pre = time.time()
 
-            # garbage collect these connections
-            self.thread_connections.clear()
-            self.threads_compute_connections.clear()
+                cursor = cast(DatabricksSQLConnectionWrapper, connection.handle).cursor()
+                cursor.execute(sql, bindings)
 
-    def _get_compute_connection(
-        self, name: Optional[str] = None, query_header_context: Any = None
-    ) -> Connection:
-        """Called by 'set_connection_name' in DatabricksConnectionManager.
-        Creates a connection for this thread/node if one doesn't already
-        exist, and will rename an existing connection."""
+                fire_event(
+                    SQLQueryStatus(
+                        status=str(self.get_response(cursor)),
+                        elapsed=round((time.time() - pre), 2),
+                        node_info=get_node_info(),
+                    )
+                )
 
-        assert (
-            USE_LONG_SESSIONS
-        ), "This path, '_get_compute_connection', should only be reachable with USE_LONG_SESSIONS"
+                return connection, cursor
+            except Error:
+                if cursor is not None:
+                    cursor.close()
+                    cursor = None
+                raise
+            finally:
+                if close_cursor and cursor is not None:
+                    cursor.close()
 
-        self._cleanup_idle_connections()
+    def execute(
+        self,
+        sql: str,
+        auto_begin: bool = False,
+        fetch: bool = False,
+        limit: Optional[int] = None,
+    ) -> Tuple[DatabricksAdapterResponse, Table]:
+        sql = self._add_query_comment(sql)
+        _, cursor = self.add_query(sql, auto_begin)
+        try:
+            response = self.get_response(cursor)
+            if fetch:
+                table = self.get_result_from_cursor(cursor, limit)
+            else:
+                table = agate_helper.empty_table()
+            return response, table
+        finally:
+            cursor.close()
 
-        conn_name: str = "master" if name is None else name
+    def _execute_cursor(
+        self, log_sql: str, f: Callable[[DatabricksSQLCursorWrapper], None]
+    ) -> Table:
+        connection = self.get_thread_connection()
 
-        # Get a connection for this thread
-        conn = self._get_if_exists_compute_connection(_get_compute_name(query_header_context) or "")
-
-        if conn is None:
-            conn = self._create_compute_connection(conn_name, query_header_context)
-        else:  # existing connection either wasn't open or didn't have the right name
-            conn = self._update_compute_connection(conn, conn_name)
-
-        conn._acquire(query_header_context)
-
-        return conn
-
-    def _update_compute_connection(
-        self, conn: DatabricksDBTConnection, new_name: str
-    ) -> DatabricksDBTConnection:
-        """Update a connection that is being re-used with a new name, handle, etc."""
-        assert USE_LONG_SESSIONS, (
-            "This path, '_update_compute_connection', should only be "
-            "reachable with USE_LONG_SESSIONS"
-        )
-
-        if conn.name == new_name and conn.state == ConnectionState.OPEN:
-            # Found a connection and nothing to do, so just return it
-            return conn
-
-        orig_conn_name: str = conn.name or ""
-
-        if conn.state != ConnectionState.OPEN:
-            conn.handle = LazyHandle(self._open2)
-        if conn.name != new_name:
-            conn.name = new_name
-            fire_event(ConnectionReused(orig_conn_name=orig_conn_name, conn_name=new_name))
-
-        current_thread_conn = cast(Optional[DatabricksDBTConnection], self.get_if_exists())
-        if current_thread_conn and current_thread_conn.compute_name != conn.compute_name:
-            self.clear_thread_connection()
-            self.set_thread_connection(conn)
-
-        conn._log_info(f"reusing connection {orig_conn_name}")
-
-        return conn
-
-    def _create_compute_connection(
-        self, conn_name: str, query_header_context: Any = None
-    ) -> DatabricksDBTConnection:
-        """Create anew connection for the combination of current thread and compute associated
-        with the given node."""
-        assert USE_LONG_SESSIONS, (
-            "This path, '_create_compute_connection', should only be reachable "
-            "with USE_LONG_SESSIONS"
-        )
-
-        # Create a new connection
-        compute_name = _get_compute_name(query_header_context) or ""
-
-        conn = DatabricksDBTConnection(
-            type=Identifier(self.TYPE),
-            name=conn_name,
-            state=ConnectionState.INIT,
-            transaction_open=False,
-            handle=None,
-            credentials=self.profile.credentials,
-        )
-        conn.compute_name = compute_name
-        creds = cast(DatabricksCredentials, self.profile.credentials)
-        conn.http_path = _get_http_path(query_header_context, creds=creds) or ""
-        conn.thread_identifier = cast(Tuple[int, int], self.get_thread_identifier())
-        conn.max_idle_time = _get_max_idle_time(query_header_context, creds=creds)
-
-        conn.handle = LazyHandle(self._open2)
-
-        conn._log_info("Creating DatabricksDBTConnection")
-
-        # Add this connection to the thread/compute connection pool.
-        self._add_compute_connection(conn)
-        # Remove the connection currently in use by this thread from the thread connection pool.
-        self.clear_thread_connection()
-        # Add the connection to thread connection pool.
-        self.set_thread_connection(conn)
-
-        fire_event(
-            NewConnection(conn_name=conn_name, conn_type=self.TYPE, node_info=get_node_info())
-        )
-
-        return conn
-
-    def _add_compute_connection(self, conn: DatabricksDBTConnection) -> None:
-        """Add a new connection to the map of connection per thread per compute."""
-        assert (
-            USE_LONG_SESSIONS
-        ), "This path, '_add_compute_connection', should only be reachable with USE_LONG_SESSIONS"
-
-        with self.lock:
-            thread_map = self._get_compute_connections()
-            if conn.compute_name in thread_map:
-                raise DbtInternalError(
-                    f"In set_thread_compute_connection, connection exists for `{conn.compute_name}`"
-                )
-            thread_map[conn.compute_name] = conn
-
-    def _get_compute_connections(
-        self,
-    ) -> Dict[Hashable, DatabricksDBTConnection]:
-        """Retrieve a map of compute name to connection for the current thread."""
-        assert (
-            USE_LONG_SESSIONS
-        ), "This path, '_get_compute_connections', should only be reachable with USE_LONG_SESSIONS"
-
-        thread_id = self.get_thread_identifier()
-        with self.lock:
-            thread_map = self.threads_compute_connections.get(thread_id)
-            if not thread_map:
-                thread_map = {}
-                self.threads_compute_connections[thread_id] = thread_map
-            return thread_map
-
-    def _get_if_exists_compute_connection(
-        self, compute_name: str
-    ) -> Optional[DatabricksDBTConnection]:
-        """Get the connection for the current thread and named compute, if it exists."""
-        assert USE_LONG_SESSIONS, (
-            "This path, '_get_if_exists_compute_connection', should only be reachable "
-            "with USE_LONG_SESSIONS"
-        )
-
-        with self.lock:
-            threads_map = self._get_compute_connections()
-            return threads_map.get(compute_name)
-
-    def _cleanup_idle_connections(self) -> None:
-        assert (
-            USE_LONG_SESSIONS
-        ), "This path, '_cleanup_idle_connections', should only be reachable with USE_LONG_SESSIONS"
-
-        with self.lock:
-            # Get all connections associated with this thread. There can be multiple connections
-            # if different models use different compute resources
-            thread_conns = self._get_compute_connections()
-            for conn in thread_conns.values():
-                conn._log_info("idle check connection:")
-
-                # Generally speaking we only want to close/refresh the connection if the
-                # acquire_release_count is zero.  i.e. the connection is not currently in use.
-                # However python models acquire a connection then run the pyton model, which
-                # doesn't actually use the connection. If the python model takes lone enought to
-                # run the connection can be idle long enough to timeout on the back end.
-                # If additional sql needs to be run after the python model, but before the
-                # connection is released, the connection needs to be refreshed or there will
-                # be a failure.  Making an exception when language is 'python' allows the
-                # the call to _cleanup_idle_connections from get_thread_connection to refresh the
-                # connection in this scenario.
-                if (
-                    conn.acquire_release_count == 0 or conn.language == "python"
-                ) and conn._idle_too_long():
-                    conn._log_info("closing idle connection")
-                    self.close(conn)
-                    conn._reset_handle(self._open2)
-
-    def get_thread_connection(self) -> Connection:
-        conn = super().get_thread_connection()
-        dbr_conn = cast(DatabricksDBTConnection, conn)
-        dbr_conn._log_info("get_thread_connection:")
-        if USE_LONG_SESSIONS:
-            self._cleanup_idle_connections()
-
-        return conn
-
-    def add_query(
-        self,
-        sql: str,
-        auto_begin: bool = True,
-        bindings: Optional[Any] = None,
-        abridge_sql_log: bool = False,
-        *,
-        close_cursor: bool = False,
-    ) -> Tuple[Connection, Any]:
-        connection = self.get_thread_connection()
-        if auto_begin and connection.transaction_open is False:
-            self.begin()
-        fire_event(ConnectionUsed(conn_type=self.TYPE, conn_name=cast_to_str(connection.name)))
-
-        with self.exception_handler(sql):
-            cursor: Optional[DatabricksSQLCursorWrapper] = None
-            try:
-                log_sql = redact_credentials(sql)
-                if abridge_sql_log:
-                    log_sql = "{}...".format(log_sql[:512])
-
-                fire_event(
-                    SQLQuery(
-                        conn_name=cast_to_str(connection.name),
-                        sql=log_sql,
-                        node_info=get_node_info(),
-                    )
-                )
-
-                pre = time.time()
-
-                cursor = cast(DatabricksSQLConnectionWrapper, connection.handle).cursor()
-                cursor.execute(sql, bindings)
-
-                fire_event(
-                    SQLQueryStatus(
-                        status=str(self.get_response(cursor)),
-                        elapsed=round((time.time() - pre), 2),
-                        node_info=get_node_info(),
-                    )
-                )
-
-                return connection, cursor
-            except Error:
-                if cursor is not None:
-                    cursor.close()
-                    cursor = None
-                raise
-            finally:
-                if close_cursor and cursor is not None:
-                    cursor.close()
-
-    def execute(
-        self,
-        sql: str,
-        auto_begin: bool = False,
-        fetch: bool = False,
-        limit: Optional[int] = None,
-    ) -> Tuple[DatabricksAdapterResponse, Table]:
-        sql = self._add_query_comment(sql)
-        _, cursor = self.add_query(sql, auto_begin)
-        try:
-            response = self.get_response(cursor)
-            if fetch:
-                table = self.get_result_from_cursor(cursor, limit)
-            else:
-                table = agate_helper.empty_table()
-            return response, table
-        finally:
-            cursor.close()
-
-    def _execute_cursor(
-        self, log_sql: str, f: Callable[[DatabricksSQLCursorWrapper], None]
-    ) -> Table:
-        connection = self.get_thread_connection()
-
-        fire_event(ConnectionUsed(conn_type=self.TYPE, conn_name=cast_to_str(connection.name)))
+        fire_event(ConnectionUsed(conn_type=self.TYPE, conn_name=cast_to_str(connection.name)))
 
         with self.exception_handler(log_sql):
             cursor: Optional[DatabricksSQLCursorWrapper] = None
@@ -1391,7 +716,6 @@ def open(cls, connection: Connection) -> Connection:
     @classmethod
     def _open(cls, connection: Connection, query_header_context: Any = None) -> Connection:
         if connection.state == ConnectionState.OPEN:
-            logger.debug("Connection is already open, skipping open.")
             return connection
 
         creds: DatabricksCredentials = connection.credentials
@@ -1431,6 +755,8 @@ def connect() -> DatabricksSQLConnectionWrapper:
                     _user_agent_entry=user_agent_entry,
                     **connection_parameters,
                 )
+                logger.debug(ConnectionCreated(str(conn)))
+
                 return DatabricksSQLConnectionWrapper(
                     conn,
                     is_cluster=creds.cluster_id is not None,
@@ -1438,7 +764,7 @@ def connect() -> DatabricksSQLConnectionWrapper:
                     user_agent=user_agent_entry,
                 )
             except Error as exc:
-                _log_dbsql_errors(exc)
+                logger.error(ConnectionCreateError(conn, exc))
                 raise
 
         def exponential_backoff(attempt: int) -> int:
@@ -1459,7 +785,222 @@ def exponential_backoff(attempt: int) -> int:
         )
 
     @classmethod
-    def _open2(cls, connection: Connection) -> Connection:
+    def get_response(cls, cursor: DatabricksSQLCursorWrapper) -> DatabricksAdapterResponse:
+        _query_id = getattr(cursor, "hex_query_id", None)
+        if cursor is None:
+            logger.debug("No cursor was provided. Query ID not available.")
+            query_id = "N/A"
+        else:
+            query_id = _query_id
+        message = "OK"
+        return DatabricksAdapterResponse(_message=message, query_id=query_id)  # type: ignore
+
+
+class ExtendedSessionConnectionManager(DatabricksConnectionManager):
+    def __init__(self, profile: AdapterRequiredConfig, mp_context: SpawnContext) -> None:
+        assert (
+            USE_LONG_SESSIONS
+        ), "This connection manager should only be used when USE_LONG_SESSIONS is enabled"
+        super().__init__(profile, mp_context)
+        self.threads_compute_connections: Dict[
+            Hashable, Dict[Hashable, DatabricksDBTConnection]
+        ] = {}
+
+    def set_connection_name(
+        self, name: Optional[str] = None, query_header_context: Any = None
+    ) -> Connection:
+        """Called by 'acquire_connection' in DatabricksAdapter, which is called by
+        'connection_named', called by 'connection_for(node)'.
+        Creates a connection for this thread if one doesn't already
+        exist, and will rename an existing connection."""
+
+        self._cleanup_idle_connections()
+
+        conn_name: str = "master" if name is None else name
+
+        # Get a connection for this thread
+        conn = self._get_if_exists_compute_connection(_get_compute_name(query_header_context) or "")
+
+        if conn is None:
+            conn = self._create_compute_connection(conn_name, query_header_context)
+        else:  # existing connection either wasn't open or didn't have the right name
+            conn = self._update_compute_connection(conn, conn_name)
+
+        conn._acquire(query_header_context)
+
+        return conn
+
+    # override
+    def release(self) -> None:
+        with self.lock:
+            conn = cast(Optional[DatabricksDBTConnection], self.get_if_exists())
+            if conn is None:
+                return
+
+        conn._release()
+
+    # override
+    @classmethod
+    def close(cls, connection: Connection) -> Connection:
+        try:
+            return super().close(connection)
+        except Exception as e:
+            logger.warning(f"ignoring error when closing connection: {e}")
+            connection.state = ConnectionState.CLOSED
+            return connection
+
+    # override
+    def cleanup_all(self) -> None:
+        with self.lock:
+            for thread_connections in self.threads_compute_connections.values():
+                for connection in thread_connections.values():
+                    if connection.acquire_release_count > 0:
+                        fire_event(
+                            ConnectionLeftOpenInCleanup(conn_name=cast_to_str(connection.name))
+                        )
+                    else:
+                        fire_event(
+                            ConnectionClosedInCleanup(conn_name=cast_to_str(connection.name))
+                        )
+                    self.close(connection)
+
+            # garbage collect these connections
+            self.thread_connections.clear()
+            self.threads_compute_connections.clear()
+
+    def _update_compute_connection(
+        self, conn: DatabricksDBTConnection, new_name: str
+    ) -> DatabricksDBTConnection:
+
+        if conn.name == new_name and conn.state == ConnectionState.OPEN:
+            # Found a connection and nothing to do, so just return it
+            return conn
+
+        orig_conn_name: str = conn.name or ""
+
+        if conn.state != ConnectionState.OPEN:
+            conn.handle = LazyHandle(self.open)
+        if conn.name != new_name:
+            conn.name = new_name
+            fire_event(ConnectionReused(orig_conn_name=orig_conn_name, conn_name=new_name))
+
+        current_thread_conn = cast(Optional[DatabricksDBTConnection], self.get_if_exists())
+        if current_thread_conn and current_thread_conn.compute_name != conn.compute_name:
+            self.clear_thread_connection()
+            self.set_thread_connection(conn)
+
+        logger.debug(ConnectionReuse(str(conn), orig_conn_name))
+
+        return conn
+
+    def _add_compute_connection(self, conn: DatabricksDBTConnection) -> None:
+        """Add a new connection to the map of connection per thread per compute."""
+
+        with self.lock:
+            thread_map = self._get_compute_connections()
+            if conn.compute_name in thread_map:
+                raise DbtInternalError(
+                    f"In set_thread_compute_connection, connection exists for `{conn.compute_name}`"
+                )
+            thread_map[conn.compute_name] = conn
+
+    def _get_compute_connections(
+        self,
+    ) -> Dict[Hashable, DatabricksDBTConnection]:
+        """Retrieve a map of compute name to connection for the current thread."""
+
+        thread_id = self.get_thread_identifier()
+        with self.lock:
+            thread_map = self.threads_compute_connections.get(thread_id)
+            if not thread_map:
+                thread_map = {}
+                self.threads_compute_connections[thread_id] = thread_map
+            return thread_map
+
+    def _get_if_exists_compute_connection(
+        self, compute_name: str
+    ) -> Optional[DatabricksDBTConnection]:
+        """Get the connection for the current thread and named compute, if it exists."""
+
+        with self.lock:
+            threads_map = self._get_compute_connections()
+            return threads_map.get(compute_name)
+
+    def _cleanup_idle_connections(self) -> None:
+        with self.lock:
+            # Get all connections associated with this thread. There can be multiple connections
+            # if different models use different compute resources
+            thread_conns = self._get_compute_connections()
+            for conn in thread_conns.values():
+                logger.debug(ConnectionIdleCheck(str(conn)))
+
+                # Generally speaking we only want to close/refresh the connection if the
+                # acquire_release_count is zero.  i.e. the connection is not currently in use.
+                # However python models acquire a connection then run the pyton model, which
+                # doesn't actually use the connection. If the python model takes lone enought to
+                # run the connection can be idle long enough to timeout on the back end.
+                # If additional sql needs to be run after the python model, but before the
+                # connection is released, the connection needs to be refreshed or there will
+                # be a failure.  Making an exception when language is 'python' allows the
+                # the call to _cleanup_idle_connections from get_thread_connection to refresh the
+                # connection in this scenario.
+                if (
+                    conn.acquire_release_count == 0 or conn.language == "python"
+                ) and conn._idle_too_long():
+                    logger.debug(ConnectionIdleClose(str(conn)))
+                    self.close(conn)
+                    conn._reset_handle(self._open)
+
+    def _create_compute_connection(
+        self, conn_name: str, query_header_context: Any = None
+    ) -> DatabricksDBTConnection:
+        """Create anew connection for the combination of current thread and compute associated
+        with the given node."""
+
+        # Create a new connection
+        compute_name = _get_compute_name(query_header_context) or ""
+
+        conn = DatabricksDBTConnection(
+            type=Identifier(self.TYPE),
+            name=conn_name,
+            state=ConnectionState.INIT,
+            transaction_open=False,
+            handle=None,
+            credentials=self.profile.credentials,
+        )
+        conn.compute_name = compute_name
+        creds = cast(DatabricksCredentials, self.profile.credentials)
+        conn.http_path = _get_http_path(query_header_context, creds=creds) or ""
+        conn.thread_identifier = cast(Tuple[int, int], self.get_thread_identifier())
+        conn.max_idle_time = _get_max_idle_time(query_header_context, creds=creds)
+
+        conn.handle = LazyHandle(self.open)
+
+        logger.debug(ConnectionCreate(str(conn)))
+
+        # Add this connection to the thread/compute connection pool.
+        self._add_compute_connection(conn)
+        # Remove the connection currently in use by this thread from the thread connection pool.
+        self.clear_thread_connection()
+        # Add the connection to thread connection pool.
+        self.set_thread_connection(conn)
+
+        fire_event(
+            NewConnection(conn_name=conn_name, conn_type=self.TYPE, node_info=get_node_info())
+        )
+
+        return conn
+
+    def get_thread_connection(self) -> Connection:
+        conn = super().get_thread_connection()
+        self._cleanup_idle_connections()
+        dbr_conn = cast(DatabricksDBTConnection, conn)
+        logger.debug(ConnectionRetrieve(str(dbr_conn)))
+
+        return conn
+
+    @classmethod
+    def open(cls, connection: Connection) -> Connection:
         # Once long session management is no longer under the USE_LONG_SESSIONS toggle
         # this should be renamed and replace the _open class method.
         assert (
@@ -1469,7 +1010,6 @@ def _open2(cls, connection: Connection) -> Connection:
         databricks_connection = cast(DatabricksDBTConnection, connection)
 
         if connection.state == ConnectionState.OPEN:
-            databricks_connection._log_info("Connection is already open, skipping open.")
             return connection
 
         creds: DatabricksCredentials = connection.credentials
@@ -1497,7 +1037,7 @@ def _open2(cls, connection: Connection) -> Connection:
         def connect() -> DatabricksSQLConnectionWrapper:
             try:
                 # TODO: what is the error when a user specifies a catalog they don't have access to
-                conn: DatabricksSQLConnection = dbsql.connect(
+                conn = dbsql.connect(
                     server_hostname=creds.host,
                     http_path=http_path,
                     credentials_provider=cls.credentials_provider,
@@ -1513,7 +1053,7 @@ def connect() -> DatabricksSQLConnectionWrapper:
                 if conn:
                     databricks_connection.session_id = conn.get_session_id_hex()
                 databricks_connection.last_used_time = time.time()
-                databricks_connection._log_info("session opened")
+                logger.debug(ConnectionCreated(str(databricks_connection)))
 
                 return DatabricksSQLConnectionWrapper(
                     conn,
@@ -1522,7 +1062,7 @@ def connect() -> DatabricksSQLConnectionWrapper:
                     user_agent=user_agent_entry,
                 )
             except Error as exc:
-                _log_dbsql_errors(exc)
+                logger.error(ConnectionCreateError(None, exc))
                 raise
 
         def exponential_backoff(attempt: int) -> int:
@@ -1542,24 +1082,6 @@ def exponential_backoff(attempt: int) -> int:
             retry_timeout=(timeout if timeout is not None else exponential_backoff),
         )
 
-    @classmethod
-    def get_response(cls, cursor: DatabricksSQLCursorWrapper) -> DatabricksAdapterResponse:
-        _query_id = getattr(cursor, "hex_query_id", None)
-        if cursor is None:
-            logger.debug("No cursor was provided. Query ID not available.")
-            query_id = "N/A"
-        else:
-            query_id = _query_id
-        message = "OK"
-        return DatabricksAdapterResponse(_message=message, query_id=query_id)  # type: ignore
-
-
-def _log_dbsql_errors(exc: Exception) -> None:
-    if isinstance(exc, Error):
-        logger.debug(f"{type(exc)}: {exc}")
-        for key, value in sorted(exc.context.items()):
-            logger.debug(f"{key}: {value}")
-
 
 def _should_poll_refresh(sql: str) -> Tuple[bool, str]:
     # if the command was to refresh a materialized view we need to poll
diff --git a/dbt/adapters/databricks/credentials.py b/dbt/adapters/databricks/credentials.py
new file mode 100644
index 000000000..b489c122d
--- /dev/null
+++ b/dbt/adapters/databricks/credentials.py
@@ -0,0 +1,396 @@
+import itertools
+import json
+import os
+import re
+import threading
+from dataclasses import dataclass
+from typing import Any
+from typing import cast
+from typing import Dict
+from typing import Iterable
+from typing import List
+from typing import Optional
+from typing import Tuple
+from typing import Union
+
+import keyring
+from databricks.sdk.core import CredentialsProvider
+from databricks.sdk.oauth import OAuthClient
+from databricks.sdk.oauth import SessionCredentials
+from dbt.adapters.contracts.connection import Credentials
+from dbt.adapters.databricks.auth import m2m_auth
+from dbt.adapters.databricks.auth import token_auth
+from dbt.adapters.databricks.events.credential_events import CredentialLoadError
+from dbt.adapters.databricks.events.credential_events import CredentialSaveError
+from dbt.adapters.databricks.events.credential_events import CredentialShardEvent
+from dbt.adapters.databricks.logging import logger
+from dbt_common.exceptions import DbtConfigError
+from dbt_common.exceptions import DbtValidationError
+
+CATALOG_KEY_IN_SESSION_PROPERTIES = "databricks.catalog"
+DBT_DATABRICKS_INVOCATION_ENV = "DBT_DATABRICKS_INVOCATION_ENV"
+DBT_DATABRICKS_INVOCATION_ENV_REGEX = re.compile("^[A-z0-9\\-]+$")
+EXTRACT_CLUSTER_ID_FROM_HTTP_PATH_REGEX = re.compile(r"/?sql/protocolv1/o/\d+/(.*)")
+DBT_DATABRICKS_HTTP_SESSION_HEADERS = "DBT_DATABRICKS_HTTP_SESSION_HEADERS"
+
+REDIRECT_URL = "http://localhost:8020"
+CLIENT_ID = "dbt-databricks"
+SCOPES = ["all-apis", "offline_access"]
+MAX_NT_PASSWORD_SIZE = 1280
+
+TCredentialProvider = Union[CredentialsProvider, SessionCredentials]
+
+
+@dataclass
+class DatabricksCredentials(Credentials):
+    database: Optional[str] = None  # type: ignore[assignment]
+    schema: Optional[str] = None  # type: ignore[assignment]
+    host: Optional[str] = None
+    http_path: Optional[str] = None
+    token: Optional[str] = None
+    client_id: Optional[str] = None
+    client_secret: Optional[str] = None
+    oauth_redirect_url: Optional[str] = None
+    oauth_scopes: Optional[List[str]] = None
+    session_properties: Optional[Dict[str, Any]] = None
+    connection_parameters: Optional[Dict[str, Any]] = None
+    auth_type: Optional[str] = None
+
+    # Named compute resources specified in the profile. Used for
+    # creating a connection when a model specifies a compute resource.
+    compute: Optional[Dict[str, Any]] = None
+
+    connect_retries: int = 1
+    connect_timeout: Optional[int] = None
+    retry_all: bool = False
+    connect_max_idle: Optional[int] = None
+
+    _credentials_provider: Optional[Dict[str, Any]] = None
+    _lock = threading.Lock()  # to avoid concurrent auth
+
+    _ALIASES = {
+        "catalog": "database",
+        "target_catalog": "target_database",
+    }
+
+    @classmethod
+    def __pre_deserialize__(cls, data: Dict[Any, Any]) -> Dict[Any, Any]:
+        data = super().__pre_deserialize__(data)
+        if "database" not in data:
+            data["database"] = None
+        return data
+
+    def __post_init__(self) -> None:
+        if "." in (self.schema or ""):
+            raise DbtValidationError(
+                f"The schema should not contain '.': {self.schema}\n"
+                "If you are trying to set a catalog, please use `catalog` instead.\n"
+            )
+
+        session_properties = self.session_properties or {}
+        if CATALOG_KEY_IN_SESSION_PROPERTIES in session_properties:
+            if self.database is None:
+                self.database = session_properties[CATALOG_KEY_IN_SESSION_PROPERTIES]
+                del session_properties[CATALOG_KEY_IN_SESSION_PROPERTIES]
+            else:
+                raise DbtValidationError(
+                    f"Got duplicate keys: (`{CATALOG_KEY_IN_SESSION_PROPERTIES}` "
+                    'in session_properties) all map to "database"'
+                )
+        self.session_properties = session_properties
+
+        if self.database is not None:
+            database = self.database.strip()
+            if not database:
+                raise DbtValidationError(f"Invalid catalog name : `{self.database}`.")
+            self.database = database
+        else:
+            self.database = "hive_metastore"
+
+        connection_parameters = self.connection_parameters or {}
+        for key in (
+            "server_hostname",
+            "http_path",
+            "access_token",
+            "client_id",
+            "client_secret",
+            "session_configuration",
+            "catalog",
+            "schema",
+            "_user_agent_entry",
+        ):
+            if key in connection_parameters:
+                raise DbtValidationError(f"The connection parameter `{key}` is reserved.")
+        if "http_headers" in connection_parameters:
+            http_headers = connection_parameters["http_headers"]
+            if not isinstance(http_headers, dict) or any(
+                not isinstance(key, str) or not isinstance(value, str)
+                for key, value in http_headers.items()
+            ):
+                raise DbtValidationError(
+                    "The connection parameter `http_headers` should be dict of strings: "
+                    f"{http_headers}."
+                )
+        if "_socket_timeout" not in connection_parameters:
+            connection_parameters["_socket_timeout"] = 600
+        self.connection_parameters = connection_parameters
+
+    def validate_creds(self) -> None:
+        for key in ["host", "http_path"]:
+            if not getattr(self, key):
+                raise DbtConfigError(
+                    "The config '{}' is required to connect to Databricks".format(key)
+                )
+        if not self.token and self.auth_type != "oauth":
+            raise DbtConfigError(
+                ("The config `auth_type: oauth` is required when not using access token")
+            )
+
+        if not self.client_id and self.client_secret:
+            raise DbtConfigError(
+                (
+                    "The config 'client_id' is required to connect "
+                    "to Databricks when 'client_secret' is present"
+                )
+            )
+
+    @classmethod
+    def get_invocation_env(cls) -> Optional[str]:
+        invocation_env = os.environ.get(DBT_DATABRICKS_INVOCATION_ENV)
+        if invocation_env:
+            # Thrift doesn't allow nested () so we need to ensure
+            # that the passed user agent is valid.
+            if not DBT_DATABRICKS_INVOCATION_ENV_REGEX.search(invocation_env):
+                raise DbtValidationError(f"Invalid invocation environment: {invocation_env}")
+        return invocation_env
+
+    @classmethod
+    def get_all_http_headers(cls, user_http_session_headers: Dict[str, str]) -> Dict[str, str]:
+        http_session_headers_str: Optional[str] = os.environ.get(
+            DBT_DATABRICKS_HTTP_SESSION_HEADERS
+        )
+
+        http_session_headers_dict: Dict[str, str] = (
+            {
+                k: v if isinstance(v, str) else json.dumps(v)
+                for k, v in json.loads(http_session_headers_str).items()
+            }
+            if http_session_headers_str is not None
+            else {}
+        )
+
+        intersect_http_header_keys = (
+            user_http_session_headers.keys() & http_session_headers_dict.keys()
+        )
+
+        if len(intersect_http_header_keys) > 0:
+            raise DbtValidationError(
+                f"Intersection with reserved http_headers in keys: {intersect_http_header_keys}"
+            )
+
+        http_session_headers_dict.update(user_http_session_headers)
+
+        return http_session_headers_dict
+
+    @property
+    def type(self) -> str:
+        return "databricks"
+
+    @property
+    def unique_field(self) -> str:
+        return cast(str, self.host)
+
+    def connection_info(self, *, with_aliases: bool = False) -> Iterable[Tuple[str, Any]]:
+        as_dict = self.to_dict(omit_none=False)
+        connection_keys = set(self._connection_keys(with_aliases=with_aliases))
+        aliases: List[str] = []
+        if with_aliases:
+            aliases = [k for k, v in self._ALIASES.items() if v in connection_keys]
+        for key in itertools.chain(self._connection_keys(with_aliases=with_aliases), aliases):
+            if key in as_dict:
+                yield key, as_dict[key]
+
+    def _connection_keys(self, *, with_aliases: bool = False) -> Tuple[str, ...]:
+        # Assuming `DatabricksCredentials.connection_info(self, *, with_aliases: bool = False)`
+        # is called from only:
+        #
+        # - `Profile` with `with_aliases=True`
+        # - `DebugTask` without `with_aliases` (`False` by default)
+        #
+        # Thus, if `with_aliases` is `True`, `DatabricksCredentials._connection_keys` should return
+        # the internal key names; otherwise it can use aliases to show in `dbt debug`.
+        connection_keys = ["host", "http_path", "schema"]
+        if with_aliases:
+            connection_keys.insert(2, "database")
+        elif self.database:
+            connection_keys.insert(2, "catalog")
+        if self.session_properties:
+            connection_keys.append("session_properties")
+        return tuple(connection_keys)
+
+    @classmethod
+    def extract_cluster_id(cls, http_path: str) -> Optional[str]:
+        m = EXTRACT_CLUSTER_ID_FROM_HTTP_PATH_REGEX.match(http_path)
+        if m:
+            return m.group(1).strip()
+        else:
+            return None
+
+    @property
+    def cluster_id(self) -> Optional[str]:
+        return self.extract_cluster_id(self.http_path)  # type: ignore[arg-type]
+
+    def authenticate(self, in_provider: Optional[TCredentialProvider]) -> TCredentialProvider:
+        self.validate_creds()
+        host: str = self.host or ""
+        if self._credentials_provider:
+            return self._provider_from_dict()  # type: ignore
+        if in_provider:
+            if isinstance(in_provider, m2m_auth) or isinstance(in_provider, token_auth):
+                self._credentials_provider = in_provider.as_dict()
+            return in_provider
+
+        provider: TCredentialProvider
+        # dbt will spin up multiple threads. This has to be sync. So lock here
+        self._lock.acquire()
+        try:
+            if self.token:
+                provider = token_auth(self.token)
+                self._credentials_provider = provider.as_dict()
+                return provider
+
+            if self.client_id and self.client_secret:
+                provider = m2m_auth(
+                    host=host,
+                    client_id=self.client_id or "",
+                    client_secret=self.client_secret or "",
+                )
+                self._credentials_provider = provider.as_dict()
+                return provider
+
+            oauth_client = OAuthClient(
+                host=host,
+                client_id=self.client_id or CLIENT_ID,
+                client_secret="",
+                redirect_url=self.oauth_redirect_url or REDIRECT_URL,
+                scopes=self.oauth_scopes or SCOPES,
+            )
+            # optional branch. Try and keep going if it does not work
+            try:
+                # try to get cached credentials
+                credsdict = self.get_sharded_password("dbt-databricks", host)
+
+                if credsdict:
+                    provider = SessionCredentials.from_dict(oauth_client, json.loads(credsdict))
+                    # if refresh token is expired, this will throw
+                    try:
+                        if provider.token().valid:
+                            return provider
+                    except Exception as e:
+                        logger.warning(CredentialLoadError(e))
+                        # whatever it is, get rid of the cache
+                        self.delete_sharded_password("dbt-databricks", host)
+
+            # error with keyring. Maybe machine has no password persistency
+            except Exception as e:
+                logger.warning(CredentialLoadError(e))
+
+            # no token, go fetch one
+            consent = oauth_client.initiate_consent()
+
+            provider = consent.launch_external_browser()
+            # save for later
+            self._credentials_provider = provider.as_dict()
+            try:
+                self.set_sharded_password(
+                    "dbt-databricks", host, json.dumps(self._credentials_provider)
+                )
+            # error with keyring. Maybe machine has no password persistency
+            except Exception as e:
+                logger.warning(CredentialSaveError(e))
+
+            return provider
+
+        finally:
+            self._lock.release()
+
+    def set_sharded_password(self, service_name: str, username: str, password: str) -> None:
+        max_size = MAX_NT_PASSWORD_SIZE
+
+        # if not Windows or "small" password, stick to the default
+        if os.name != "nt" or len(password) < max_size:
+            keyring.set_password(service_name, username, password)
+        else:
+            logger.debug(CredentialShardEvent(len(password)))
+
+            password_shards = [
+                password[i : i + max_size] for i in range(0, len(password), max_size)
+            ]
+            shard_info = {
+                "sharded_password": True,
+                "shard_count": len(password_shards),
+            }
+
+            # store the "shard info" as the "base" password
+            keyring.set_password(service_name, username, json.dumps(shard_info))
+            # then store all shards with the shard number as postfix
+            for i, s in enumerate(password_shards):
+                keyring.set_password(service_name, f"{username}__{i}", s)
+
+    def get_sharded_password(self, service_name: str, username: str) -> Optional[str]:
+        password = keyring.get_password(service_name, username)
+
+        # check for "shard info" stored as json
+        try:
+            password_as_dict = json.loads(str(password))
+            if password_as_dict.get("sharded_password"):
+                # if password was stored shared, reconstruct it
+                shard_count = int(password_as_dict.get("shard_count"))
+
+                password = ""
+                for i in range(shard_count):
+                    password += str(keyring.get_password(service_name, f"{username}__{i}"))
+        except ValueError:
+            pass
+
+        return password
+
+    def delete_sharded_password(self, service_name: str, username: str) -> None:
+        password = keyring.get_password(service_name, username)
+
+        # check for "shard info" stored as json. If so delete all shards
+        try:
+            password_as_dict = json.loads(str(password))
+            if password_as_dict.get("sharded_password"):
+                shard_count = int(password_as_dict.get("shard_count"))
+                for i in range(shard_count):
+                    keyring.delete_password(service_name, f"{username}__{i}")
+        except ValueError:
+            pass
+
+        # delete "base" password
+        keyring.delete_password(service_name, username)
+
+    def _provider_from_dict(self) -> Optional[TCredentialProvider]:
+        if self.token:
+            return token_auth.from_dict(self._credentials_provider)
+
+        if self.client_id and self.client_secret:
+            return m2m_auth.from_dict(
+                host=self.host or "",
+                client_id=self.client_id or "",
+                client_secret=self.client_secret or "",
+                raw=self._credentials_provider or {"token": {}},
+            )
+
+        oauth_client = OAuthClient(
+            host=self.host or "",
+            client_id=self.client_id or CLIENT_ID,
+            client_secret="",
+            redirect_url=self.oauth_redirect_url or REDIRECT_URL,
+            scopes=self.oauth_scopes or SCOPES,
+        )
+
+        return SessionCredentials.from_dict(
+            client=oauth_client, raw=self._credentials_provider or {"token": {}}
+        )
diff --git a/dbt/adapters/databricks/events/base.py b/dbt/adapters/databricks/events/base.py
new file mode 100644
index 000000000..3e9e257c3
--- /dev/null
+++ b/dbt/adapters/databricks/events/base.py
@@ -0,0 +1,28 @@
+from abc import ABC
+
+from databricks.sql.exc import Error
+
+
+class ErrorEvent(ABC):
+    def __init__(self, exception: Exception, message: str):
+        self.message = message
+        self.exception = exception
+
+    def __str__(self) -> str:
+        return f"{self.message}: {self.exception}"
+
+
+class SQLErrorEvent:
+    def __init__(self, exception: Exception, message: str):
+        self.message = message
+        self.exception = exception
+
+    def __str__(self) -> str:
+        properties = ""
+        if isinstance(self.exception, Error):
+            properties = "\nError properties: "
+            properties += ", ".join(
+                [f"{key}={value}" for key, value in sorted(self.exception.context.items())]
+            )
+
+        return f"{self.message}: {self.exception}{properties}"
diff --git a/dbt/adapters/databricks/events/connection_events.py b/dbt/adapters/databricks/events/connection_events.py
new file mode 100644
index 000000000..769384f37
--- /dev/null
+++ b/dbt/adapters/databricks/events/connection_events.py
@@ -0,0 +1,121 @@
+from abc import ABC
+from typing import Any
+from typing import Optional
+from typing import Tuple
+
+from databricks.sql.client import Connection
+from dbt.adapters.databricks.events.base import SQLErrorEvent
+
+
+class ConnectionEvent(ABC):
+    def __init__(self, connection: Optional[Connection], message: str):
+        self.message = message
+        self.session_id = "Unknown"
+        if connection:
+            self.session_id = connection.get_session_id_hex() or "Unknown"
+
+    def __str__(self) -> str:
+        return f"Connection(session-id={self.session_id}) - {self.message}"
+
+
+class ConnectionCancel(ConnectionEvent):
+    def __init__(self, connection: Optional[Connection]):
+        super().__init__(connection, "Cancelling connection")
+
+
+class ConnectionClose(ConnectionEvent):
+    def __init__(self, connection: Optional[Connection]):
+        super().__init__(connection, "Closing connection")
+
+
+class ConnectionCancelError(ConnectionEvent):
+    def __init__(self, connection: Optional[Connection], exception: Exception):
+        super().__init__(
+            connection, str(SQLErrorEvent(exception, "Exception while trying to cancel connection"))
+        )
+
+
+class ConnectionCloseError(ConnectionEvent):
+    def __init__(self, connection: Optional[Connection], exception: Exception):
+        super().__init__(
+            connection, str(SQLErrorEvent(exception, "Exception while trying to close connection"))
+        )
+
+
+class ConnectionCreateError(ConnectionEvent):
+    def __init__(self, connection: Optional[Connection], exception: Exception):
+        super().__init__(
+            connection, str(SQLErrorEvent(exception, "Exception while trying to create connection"))
+        )
+
+
+class ConnectionWrapperEvent(ABC):
+    def __init__(self, description: str, message: str):
+        self.message = message
+        self.description = description
+
+    def __str__(self) -> str:
+        return f"{self.description} - {self.message}"
+
+
+class ConnectionAcquire(ConnectionWrapperEvent):
+    def __init__(
+        self,
+        description: str,
+        model: Optional[Any],
+        compute_name: Optional[str],
+        thread_identifier: Tuple[int, int],
+    ):
+        message = f"Acquired connection on thread {thread_identifier}, using "
+        if not compute_name:
+            message += "default compute resource"
+        else:
+            message += f"compute resource '{compute_name}'"
+
+        if model:
+            # ResultNode *should* have relation_name attr, but we work around a core
+            # issue by checking.
+            relation_name = getattr(model, "relation_name", "[Unknown]")
+            message += f" for model '{relation_name}'"
+
+        super().__init__(description, message)
+
+
+class ConnectionRelease(ConnectionWrapperEvent):
+    def __init__(self, description: str):
+        super().__init__(description, "Released connection")
+
+
+class ConnectionReset(ConnectionWrapperEvent):
+    def __init__(self, description: str):
+        super().__init__(description, "Reset connection handle")
+
+
+class ConnectionReuse(ConnectionWrapperEvent):
+    def __init__(self, description: str, prior_name: str):
+        super().__init__(description, f"Reusing connection previously named {prior_name}")
+
+
+class ConnectionCreate(ConnectionWrapperEvent):
+    def __init__(self, description: str):
+        super().__init__(description, "Creating connection")
+
+
+class ConnectionIdleCheck(ConnectionWrapperEvent):
+    def __init__(self, description: str):
+        super().__init__(description, "Checking idleness")
+
+
+class ConnectionIdleClose(ConnectionWrapperEvent):
+    def __init__(self, description: str):
+        super().__init__(description, "Closing for idleness")
+
+
+class ConnectionRetrieve(ConnectionWrapperEvent):
+    def __init__(self, description: str):
+        super().__init__(description, "Retrieving connection")
+
+
+class ConnectionCreated(ConnectionWrapperEvent):
+    def __init__(self, description: str):
+        super().__init__(description, "Connection created")
diff --git a/dbt/adapters/databricks/events/credential_events.py b/dbt/adapters/databricks/events/credential_events.py
new file mode 100644
index 000000000..41255ff08
--- /dev/null
+++ b/dbt/adapters/databricks/events/credential_events.py
@@ -0,0 +1,19 @@
+from dbt.adapters.databricks.events.base import ErrorEvent
+
+
+class CredentialLoadError(ErrorEvent):
+    def __init__(self, exception: Exception):
+        super().__init__(exception, "Exception while trying to load credentials")
+
+
+class CredentialSaveError(ErrorEvent):
+    def __init__(self, exception: Exception):
+        super().__init__(exception, "Exception while trying to save credentials")
+
+
+class CredentialShardEvent:
+    def __init__(self, password_len: int):
+        self.password_len = password_len
+
+    def __str__(self) -> str:
+        return f"Password is {self.password_len} characters, sharding it"
diff --git a/dbt/adapters/databricks/events/cursor_events.py b/dbt/adapters/databricks/events/cursor_events.py
new file mode 100644
index 000000000..4f87c2dbf
--- /dev/null
+++ b/dbt/adapters/databricks/events/cursor_events.py
@@ -0,0 +1,58 @@
+from abc import ABC
+from uuid import UUID
+
+from databricks.sql.client import Cursor
+from dbt.adapters.databricks.events.base import SQLErrorEvent
+
+
+class CursorEvent(ABC):
+    def __init__(self, cursor: Cursor, message: str):
+        self.message = message
+        self.session_id = "Unknown"
+        self.command_id = "Unknown"
+        if cursor:
+            if cursor.connection:
+                self.session_id = cursor.connection.get_session_id_hex()
+            if (
+                cursor.active_result_set
+                and cursor.active_result_set.command_id
+                and cursor.active_result_set.command_id.operationId
+            ):
+                self.command_id = (
+                    str(UUID(bytes=cursor.active_result_set.command_id.operationId.guid))
+                    or "Unknown"
+                )
+
+    def __str__(self) -> str:
+        return (
+            f"Cursor(session-id={self.session_id}, command-id={self.command_id}) - {self.message}"
+        )
+
+
+class CursorCloseError(CursorEvent):
+    def __init__(self, cursor: Cursor, exception: Exception):
+        super().__init__(
+            cursor, str(SQLErrorEvent(exception, "Exception while trying to close cursor"))
+        )
+
+
+class CursorCancelError(CursorEvent):
+    def __init__(self, cursor: Cursor, exception: Exception):
+        super().__init__(
+            cursor, str(SQLErrorEvent(exception, "Exception while trying to cancel cursor"))
+        )
+
+
+class CursorCreate(CursorEvent):
+    def __init__(self, cursor: Cursor):
+        super().__init__(cursor, "Created cursor")
+
+
+class CursorClose(CursorEvent):
+    def __init__(self, cursor: Cursor):
+        super().__init__(cursor, "Closing cursor")
+
+
+class CursorCancel(CursorEvent):
+    def __init__(self, cursor: Cursor):
+        super().__init__(cursor, "Cancelling cursor")
diff --git a/dbt/adapters/databricks/events/other_events.py b/dbt/adapters/databricks/events/other_events.py
new file mode 100644
index 000000000..7db806e90
--- /dev/null
+++ b/dbt/adapters/databricks/events/other_events.py
@@ -0,0 +1,6 @@
+from dbt.adapters.databricks.events.base import SQLErrorEvent
+
+
+class QueryError(SQLErrorEvent):
+    def __init__(self, log_sql: str, exception: Exception):
+        super().__init__(exception, f"Exception while trying to execute query\n{log_sql}\n")
diff --git a/dbt/adapters/databricks/events/pipeline_events.py b/dbt/adapters/databricks/events/pipeline_events.py
new file mode 100644
index 000000000..5458b7181
--- /dev/null
+++ b/dbt/adapters/databricks/events/pipeline_events.py
@@ -0,0 +1,25 @@
+from abc import ABC
+
+
+class PipelineEvent(ABC):
+    def __init__(self, pipeline_id: str, update_id: str, message: str):
+        self.pipeline_id = pipeline_id
+        self.update_id = update_id
+        self.message = message
+
+    def __str__(self) -> str:
+        return (
+            f"Pipeline(pipeline-id={self.pipeline_id}, update-id={self.update_id}) - {self.message}"
+        )
+
+
+class PipelineRefresh(PipelineEvent):
+    def __init__(self, pipeline_id: str, update_id: str, model_name: str, state: str):
+        super().__init__(
+            pipeline_id, update_id, f"Refreshing model {model_name} with state {state}"
+        )
+
+
+class PipelineRefreshError(PipelineEvent):
+    def __init__(self, pipeline_id: str, update_id: str, message: str):
+        super().__init__(pipeline_id, update_id, f"Error refreshing pipeline: {message}")
diff --git a/dbt/adapters/databricks/impl.py b/dbt/adapters/databricks/impl.py
index 0dcf9ce9e..8d95a3e1b 100644
--- a/dbt/adapters/databricks/impl.py
+++ b/dbt/adapters/databricks/impl.py
@@ -1,78 +1,79 @@
-from abc import ABC, abstractmethod
+import os
+import re
+from abc import ABC
+from abc import abstractmethod
 from collections import defaultdict
 from concurrent.futures import Future
 from contextlib import contextmanager
 from dataclasses import dataclass
-import os
-import re
-from typing import (
-    Any,
-    ClassVar,
-    Dict,
-    FrozenSet,
-    Generic,
-    Iterable,
-    Iterator,
-    List,
-    Optional,
-    Set,
-    Tuple,
-    Type,
-    Union,
-)
-
-from agate import Row, Table, Text
-
-from dbt.adapters.base import AdapterConfig, PythonJobHelper
+from typing import Any
+from typing import Callable
+from typing import ClassVar
+from typing import Dict
+from typing import FrozenSet
+from typing import Generic
+from typing import Iterable
+from typing import Iterator
+from typing import List
+from typing import Optional
+from typing import Set
+from typing import Tuple
+from typing import Type
+from typing import TypeVar
+from typing import Union
+
+from agate import Row
+from agate import Table
+from agate import Text
+from dbt.adapters.base import AdapterConfig
+from dbt.adapters.base import PythonJobHelper
 from dbt.adapters.base.impl import catch_as_completed
 from dbt.adapters.base.meta import available
-from dbt.adapters.base.relation import BaseRelation, InformationSchema
-from dbt.adapters.capability import (
-    CapabilityDict,
-    CapabilitySupport,
-    Support,
-    Capability,
-)
-from dbt.adapters.spark.impl import (
-    SparkAdapter,
-    DESCRIBE_TABLE_EXTENDED_MACRO_NAME,
-    GET_COLUMNS_IN_RELATION_RAW_MACRO_NAME,
-    KEY_TABLE_OWNER,
-    KEY_TABLE_STATISTICS,
-    LIST_RELATIONS_MACRO_NAME,
-    LIST_SCHEMAS_MACRO_NAME,
-    TABLE_OR_VIEW_NOT_FOUND_MESSAGES,
-)
-from dbt_common.clients.agate_helper import DEFAULT_TYPE_TESTER, empty_table
-from dbt.adapters.contracts.connection import AdapterResponse, Connection
+from dbt.adapters.base.relation import BaseRelation
+from dbt.adapters.capability import Capability
+from dbt.adapters.capability import CapabilityDict
+from dbt.adapters.capability import CapabilitySupport
+from dbt.adapters.capability import Support
+from dbt.adapters.contracts.connection import AdapterResponse
+from dbt.adapters.contracts.connection import Connection
+from dbt.adapters.contracts.relation import RelationConfig
 from dbt.adapters.contracts.relation import RelationType
-from dbt.adapters.events.logging import AdapterLogger
-from dbt_common.utils import executor
-
 from dbt.adapters.databricks.column import DatabricksColumn
 from dbt.adapters.databricks.connections import DatabricksConnectionManager
+from dbt.adapters.databricks.connections import ExtendedSessionConnectionManager
+from dbt.adapters.databricks.connections import USE_LONG_SESSIONS
 from dbt.adapters.databricks.python_submissions import (
     DbtDatabricksAllPurposeClusterPythonJobHelper,
+)
+from dbt.adapters.databricks.python_submissions import (
     DbtDatabricksJobClusterPythonJobHelper,
 )
-from dbt.adapters.databricks.relation import is_hive_metastore, extract_identifiers
-from dbt.adapters.databricks.relation import (
-    DatabricksRelation,
-    DatabricksRelationType,
+from dbt.adapters.databricks.relation import DatabricksRelation
+from dbt.adapters.databricks.relation import DatabricksRelationType
+from dbt.adapters.databricks.relation_configs.base import DatabricksRelationConfig
+from dbt.adapters.databricks.relation_configs.base import DatabricksRelationConfigBase
+from dbt.adapters.databricks.relation_configs.incremental import IncrementalTableConfig
+from dbt.adapters.databricks.relation_configs.materialized_view import (
+    MaterializedViewConfig,
 )
-from dbt.adapters.databricks.relation_configs.base import (
-    DatabricksRelationConfig,
-    DatabricksRelationConfigBase,
+from dbt.adapters.databricks.relation_configs.streaming_table import (
+    StreamingTableConfig,
 )
-from dbt.adapters.databricks.relation_configs.materialized_view import MaterializedViewConfig
-from dbt.adapters.databricks.relation_configs.streaming_table import StreamingTableConfig
-from dbt.adapters.databricks.utils import redact_credentials, undefined_proof, get_first_row
+from dbt.adapters.databricks.utils import get_first_row
+from dbt.adapters.databricks.utils import redact_credentials
+from dbt.adapters.databricks.utils import undefined_proof
 from dbt.adapters.relation_configs import RelationResults
-from dbt.adapters.contracts.relation import RelationConfig
+from dbt.adapters.spark.impl import DESCRIBE_TABLE_EXTENDED_MACRO_NAME
+from dbt.adapters.spark.impl import GET_COLUMNS_IN_RELATION_RAW_MACRO_NAME
+from dbt.adapters.spark.impl import KEY_TABLE_OWNER
+from dbt.adapters.spark.impl import KEY_TABLE_STATISTICS
+from dbt.adapters.spark.impl import LIST_SCHEMAS_MACRO_NAME
+from dbt.adapters.spark.impl import SparkAdapter
+from dbt.adapters.spark.impl import TABLE_OR_VIEW_NOT_FOUND_MESSAGES
+from dbt_common.clients.agate_helper import DEFAULT_TYPE_TESTER
 from dbt_common.exceptions import DbtRuntimeError
-
-
-logger = AdapterLogger("Databricks")
+from dbt_common.utils import executor
+from dbt_common.utils.dict import AttrDict
 
 CURRENT_CATALOG_MACRO_NAME = "current_catalog"
 USE_CATALOG_MACRO_NAME = "use_catalog"
@@ -93,6 +94,7 @@ class DatabricksConfig(AdapterConfig):
     buckets: Optional[int] = None
     options: Optional[Dict[str, str]] = None
     merge_update_columns: Optional[str] = None
+    databricks_tags: Optional[Dict[str, str]] = None
     tblproperties: Optional[Dict[str, str]] = None
     zorder: Optional[Union[List[str], str]] = None
 
@@ -100,7 +102,21 @@ class DatabricksConfig(AdapterConfig):
 def check_not_found_error(errmsg: str) -> bool:
     new_error = "[SCHEMA_NOT_FOUND]" in errmsg
     old_error = re.match(r".*(Database).*(not found).*", errmsg, re.DOTALL)
-    return new_error or old_error is not None
+    found_msgs = (msg in errmsg for msg in TABLE_OR_VIEW_NOT_FOUND_MESSAGES)
+    return new_error or old_error is not None or any(found_msgs)
+
+
+T = TypeVar("T")
+
+
+def handle_missing_objects(exec: Callable[[], T], default: T) -> T:
+    try:
+        return exec()
+    except DbtRuntimeError as e:
+        errmsg = getattr(e, "msg", "")
+        if check_not_found_error(errmsg):
+            return default
+        raise e
 
 
 def get_identifier_list_string(table_names: Set[str]) -> str:
@@ -126,7 +142,11 @@ class DatabricksAdapter(SparkAdapter):
     Relation = DatabricksRelation
     Column = DatabricksColumn
 
-    ConnectionManager = DatabricksConnectionManager
+    if USE_LONG_SESSIONS:
+        ConnectionManager: Type[DatabricksConnectionManager] = ExtendedSessionConnectionManager
+    else:
+        ConnectionManager = DatabricksConnectionManager
+
     connections: DatabricksConnectionManager
 
     AdapterSpecificConfigs = DatabricksConfig
@@ -134,7 +154,7 @@ class DatabricksAdapter(SparkAdapter):
     _capabilities = CapabilityDict(
         {
             Capability.TableLastModifiedMetadata: CapabilitySupport(support=Support.Full),
-            Capability.SchemaMetadataByRelations: CapabilitySupport(support=Support.NotImplemented),
+            Capability.SchemaMetadataByRelations: CapabilitySupport(support=Support.Full),
         }
     )
 
@@ -205,74 +225,43 @@ def execute(
     def list_relations_without_caching(  # type: ignore[override]
         self, schema_relation: DatabricksRelation
     ) -> List[DatabricksRelation]:
-        kwargs = {"schema_relation": schema_relation}
-        try:
-            results = self.execute_macro(LIST_RELATIONS_MACRO_NAME, kwargs=kwargs)
-        except DbtRuntimeError as e:
-            errmsg = getattr(e, "msg", "")
-            if check_not_found_error(errmsg):
-                return []
-            else:
-                description = "Error while retrieving information about"
-                logger.debug(f"{description} {schema_relation}: {e.msg}")
-                raise e
+        results = handle_missing_objects(
+            lambda: self.get_relations_without_caching(schema_relation),
+            Table([], ["name", "kind", "file_format", "owner"]),
+        )
 
         return [
             self.Relation.create(
-                database=database,
-                schema=schema,
+                database=schema_relation.database,
+                schema=schema_relation.schema,
                 identifier=name,
                 type=self.Relation.get_relation_type(kind),
+                file_format=file_format,
+                owner=owner,
             )
-            for database, schema, name, kind in results.select(  # type: ignore[attr-defined]
-                ["database_name", "schema_name", "name", "kind"]
+            for name, kind, file_format, owner in results.select(
+                ["name", "kind", "file_format", "owner"]
             )
         ]
 
-    def _list_relations_with_information(
-        self, schema_relation: DatabricksRelation
-    ) -> List[Tuple[DatabricksRelation, str]]:
-        results: List[Row]
-        kwargs = {"schema_relation": schema_relation}
-        try:
-            # The catalog for `show table extended` needs to match the current catalog.
-            with self._catalog(schema_relation.database):
-                results = list(self.execute_macro(SHOW_TABLE_EXTENDED_MACRO_NAME, kwargs=kwargs))
-        except DbtRuntimeError as e:
-            errmsg = getattr(e, "msg", "")
-            if check_not_found_error(errmsg):
-                results = []
-            else:
-                description = "Error while retrieving information about"
-                logger.debug(f"{description} {schema_relation.without_identifier()}: {e.msg}")
-                raise e
-
-        relations: List[Tuple[DatabricksRelation, str]] = []
-        for row in results:
-            if len(row) != 4:
-                raise DbtRuntimeError(
-                    f'Invalid value from "show table extended ...", '
-                    f"got {len(row)} values, expected 4"
-                )
-            _schema, name, _, information = row
-            rel_type = RelationType.View if "Type: VIEW" in information else RelationType.Table
-            relation = self.Relation.create(
-                database=schema_relation.database,
-                # Use `_schema` retrieved from the cluster to avoid mismatched case
-                # between the profile and the cluster.
-                schema=_schema,
-                identifier=name,
-                type=rel_type,
-            )
-            relations.append((relation, information))
+    def get_relations_without_caching(self, relation: DatabricksRelation) -> Table:
+        if relation.is_hive_metastore():
+            return self._get_hive_relations(relation)
+        return self._get_uc_relations(relation)
 
-        return relations
+    def _get_uc_relations(self, relation: DatabricksRelation) -> Table:
+        kwargs = {"relation": relation}
+        tables = self.execute_macro("get_uc_tables", kwargs=kwargs)
+        return Table(
+            tables,
+            column_names=["name", "kind", "file_format", "owner"],
+            column_types=[Text(), Text(), Text(), Text()],
+        )
 
-    @available.parse(lambda *a, **k: empty_table())
-    def get_relations_without_caching(self, relation: DatabricksRelation) -> Table:
+    def _get_hive_relations(self, relation: DatabricksRelation) -> Table:
         kwargs = {"relation": relation}
 
-        new_rows: List[Tuple[Optional[str], str, str, str]]
+        new_rows: List[Tuple[str, Optional[str]]]
         if all([relation.database, relation.schema]):
             tables = self.connections.list_tables(
                 database=relation.database, schema=relation.schema  # type: ignore[arg-type]
@@ -282,126 +271,30 @@ def get_relations_without_caching(self, relation: DatabricksRelation) -> Table:
             for row in tables:
                 # list_tables returns TABLE_TYPE as view for both materialized views and for
                 # streaming tables.  Set type to "" in this case and it will be resolved below.
-                type = row["TABLE_TYPE"].lower() if row["TABLE_TYPE"].lower() != "view" else ""
-                row = (row["TABLE_CAT"], row["TABLE_SCHEM"], row["TABLE_NAME"], type)
+                type = row["TABLE_TYPE"].lower() if row["TABLE_TYPE"].lower() != "view" else None
+                row = (row["TABLE_NAME"], type)
                 new_rows.append(row)
 
         else:
             tables = self.execute_macro(SHOW_TABLES_MACRO_NAME, kwargs=kwargs)
-            new_rows = [
-                (relation.database, row["database"], row["tableName"], "") for row in tables
-            ]
+            new_rows = [(row["tableName"], None) for row in tables]
 
         # if there are any table types to be resolved
-        if any(not row[3] for row in new_rows):
-            if is_hive_metastore(relation.database):
-                new_rows = self._get_hive_types(relation, new_rows)
-            else:
-                new_rows = self._get_uc_types(relation, new_rows)
+        if any(not row[1] for row in new_rows):
+            with self._catalog(relation.database):
+                views = self.execute_macro(SHOW_VIEWS_MACRO_NAME, kwargs=kwargs)
+                view_names = set(views.columns["viewName"].values())  # type: ignore[attr-defined]
+                new_rows = [
+                    (row[0], str(RelationType.View if row[0] in view_names else RelationType.Table))
+                    for row in new_rows
+                ]
 
         return Table(
-            new_rows,
-            column_names=["database_name", "schema_name", "name", "kind"],
+            [(row[0], row[1], None, None) for row in new_rows],
+            column_names=["name", "kind", "file_format", "owner"],
             column_types=[Text(), Text(), Text(), Text()],
         )
 
-    def _get_hive_types(
-        self, relation: DatabricksRelation, new_rows: List[Tuple[Optional[str], str, str, str]]
-    ) -> List[Tuple[Optional[str], str, str, str]]:
-        kwargs = {"relation": relation}
-
-        with self._catalog(relation.database):
-            views = self.execute_macro(SHOW_VIEWS_MACRO_NAME, kwargs=kwargs)
-
-            view_names = set(views.columns["viewName"].values())  # type: ignore[attr-defined]
-            return [
-                (
-                    row[0],
-                    row[1],
-                    row[2],
-                    str(RelationType.View if row[2] in view_names else RelationType.Table),
-                )
-                for row in new_rows
-            ]
-
-    def _get_uc_types(
-        self, relation: DatabricksRelation, new_rows: List[Tuple[Optional[str], str, str, str]]
-    ) -> List[Tuple[Optional[str], str, str, str]]:
-        kwargs = {"relation": relation}
-
-        # Get view names and create a dictionary of view name to materialization
-        relation_all_tables = self.Relation.create(
-            database=relation.database, schema=relation.schema, identifier="*"
-        )
-
-        with self._catalog(relation.database):
-            views = self.execute_macro(SHOW_VIEWS_MACRO_NAME, kwargs=kwargs)
-            tables = self.execute_macro(
-                SHOW_TABLE_EXTENDED_MACRO_NAME,
-                kwargs={"schema_relation": relation_all_tables},
-            )
-        view_names: Dict[str, bool] = {
-            view["viewName"]: view.get("isMaterialized", False) for view in views
-        }
-        table_names: Dict[str, bool] = {
-            table["tableName"]: (self._parse_type(table["information"]) == "STREAMING_TABLE")
-            for table in tables
-        }
-
-        # create a new collection of rows with the correct table types
-        new_rows = [
-            (
-                row[0],
-                row[1],
-                row[2],
-                str(
-                    row[3]
-                    if row[3]
-                    else self._type_from_names(row[0], row[2], view_names, table_names)
-                ),
-            )
-            for row in new_rows
-        ]
-
-        return new_rows
-
-    def _parse_type(self, information: str) -> str:
-        type_entry = [
-            entry.split(":")[1].strip()
-            for entry in information.split("\n")
-            if entry.startswith("Type:")
-        ]
-
-        return type_entry[0] if type_entry else ""
-
-    def _type_from_names(
-        self,
-        database: Optional[str],
-        name: str,
-        view_names: Dict[str, bool],
-        table_names: Dict[str, bool],
-    ) -> DatabricksRelationType:
-        if name in view_names:
-            # it is either a view or a materialized view
-            return (
-                DatabricksRelationType.MaterializedView
-                if view_names[name]
-                else DatabricksRelationType.View
-            )
-        elif is_hive_metastore(database):
-            return DatabricksRelationType.Table
-        elif name in table_names:
-            # it is either a table or a streaming table
-            return (
-                DatabricksRelationType.StreamingTable
-                if table_names[name]
-                else DatabricksRelationType.Table
-            )
-        else:
-            raise DbtRuntimeError(
-                f"Unexpected relation type discovered: Database:{database}, Relation:{name}"
-            )
-
     def get_relation(
         self,
         database: Optional[str],
@@ -427,7 +320,6 @@ def parse_describe_extended(  # type: ignore[override]
         # Find the separator between the rows and the metadata provided
         # by the DESCRIBE TABLE EXTENDED statement
         pos = self.find_table_information_separator(dict_rows)
-
         # Remove rows that start with a hash, they are comments
         rows = [row for row in raw_rows[0:pos] if not row["col_name"].startswith("#")]
         metadata = {col["col_name"]: col["data_type"] for col in raw_rows[pos + 1 :]}
@@ -454,29 +346,40 @@ def parse_describe_extended(  # type: ignore[override]
     def get_columns_in_relation(  # type: ignore[override]
         self, relation: DatabricksRelation
     ) -> List[DatabricksColumn]:
-        return self._get_updated_relation(relation)[1]
+        rows = list(
+            handle_missing_objects(
+                lambda: self.execute_macro(
+                    GET_COLUMNS_COMMENTS_MACRO_NAME, kwargs={"relation": relation}
+                ),
+                AttrDict(),
+            )
+        )
+
+        columns = []
+        for row in rows:
+            if row["col_name"].startswith("#"):
+                break
+            columns.append(
+                DatabricksColumn(
+                    column=row["col_name"], dtype=row["data_type"], comment=row["comment"]
+                )
+            )
+
+        return columns
 
     def _get_updated_relation(
         self, relation: DatabricksRelation
     ) -> Tuple[DatabricksRelation, List[DatabricksColumn]]:
-        try:
-            rows: List[Row] = list(
-                self.execute_macro(
+        rows = list(
+            handle_missing_objects(
+                lambda: self.execute_macro(
                     GET_COLUMNS_IN_RELATION_RAW_MACRO_NAME,
                     kwargs={"relation": relation},
-                )
+                ),
+                AttrDict(),
             )
-            metadata, columns = self.parse_describe_extended(relation, rows)
-        except DbtRuntimeError as e:
-            # spark would throw error when table doesn't exist, where other
-            # CDW would just return and empty list, normalizing the behavior here
-            errmsg = getattr(e, "msg", "")
-            found_msgs = (msg in errmsg for msg in TABLE_OR_VIEW_NOT_FOUND_MESSAGES)
-            if any(found_msgs):
-                metadata = None
-                columns = []
-            else:
-                raise e
+        )
+        metadata, columns = self.parse_describe_extended(relation, rows)
 
         # strip hudi metadata columns.
         columns = [x for x in columns if x.name not in self.HUDI_METADATA_COLUMNS]
@@ -504,16 +407,16 @@ def parse_columns_from_information(  # type: ignore[override]
     ) -> List[DatabricksColumn]:
         owner_match = re.findall(self.INFORMATION_OWNER_REGEX, information)
         owner = owner_match[0] if owner_match else None
+        matches = re.finditer(self.INFORMATION_COLUMNS_REGEX, information)
         comment_match = re.findall(self.INFORMATION_COMMENT_REGEX, information)
         table_comment = comment_match[0] if comment_match else None
-        matches = re.finditer(self.INFORMATION_COLUMNS_REGEX, information)
         columns = []
         stats_match = re.findall(self.INFORMATION_STATISTICS_REGEX, information)
         raw_table_stats = stats_match[0] if stats_match else None
         table_stats = DatabricksColumn.convert_table_stats(raw_table_stats)
 
         for match_num, match in enumerate(matches):
-            column_name, column_type, nullable = match.groups()
+            column_name, column_type, _ = match.groups()
             column = DatabricksColumn(
                 table_database=relation.database,
                 table_schema=relation.schema,
@@ -529,93 +432,96 @@ def parse_columns_from_information(  # type: ignore[override]
             columns.append(column)
         return columns
 
+    def get_catalog_by_relations(
+        self, used_schemas: FrozenSet[Tuple[str, str]], relations: Set[BaseRelation]
+    ) -> Tuple[Table, List[Exception]]:
+        relation_map: Dict[Tuple[str, str], Set[str]] = defaultdict(set)
+        for relation in relations:
+            if relation.identifier:
+                relation_map[
+                    (relation.database or "hive_metastore", relation.schema or "schema")
+                ].add(relation.identifier)
+
+        return self._get_catalog_for_relation_map(relation_map, used_schemas)
+
     def get_catalog(
-        self, relation_configs: Iterable[RelationConfig], used_schemas: FrozenSet[Tuple[str, str]]
-    ) -> Tuple[Table, List[Exception]]:  # type: ignore
-        schema_map = self._get_catalog_schemas(relation_configs)
+        self,
+        relation_configs: Iterable[RelationConfig],
+        used_schemas: FrozenSet[Tuple[str, str]],
+    ) -> Tuple[Table, List[Exception]]:
+        relation_map: Dict[Tuple[str, str], Set[str]] = defaultdict(set)
+        for relation in relation_configs:
+            relation_map[(relation.database or "hive_metastore", relation.schema or "default")].add(
+                relation.identifier
+            )
+
+        return self._get_catalog_for_relation_map(relation_map, used_schemas)
 
+    def _get_catalog_for_relation_map(
+        self,
+        relation_map: Dict[Tuple[str, str], Set[str]],
+        used_schemas: FrozenSet[Tuple[str, str]],
+    ) -> Tuple[Table, List[Exception]]:
         with executor(self.config) as tpe:
             futures: List[Future[Table]] = []
-            for info, schemas in schema_map.items():
-                if is_hive_metastore(info.database):
-                    for schema in schemas:
+            for schema, relations in relation_map.items():
+                if schema in used_schemas:
+                    identifier = get_identifier_list_string(relations)
+                    if identifier:
                         futures.append(
                             tpe.submit_connected(
-                                self, "hive_metastore", self._get_hive_catalog, schema, "*"
+                                self,
+                                str(schema),
+                                self._get_schema_for_catalog,
+                                schema[0],
+                                schema[1],
+                                identifier,
                             )
                         )
-                else:
-                    name = ".".join([str(info.database), "information_schema"])
-                    fut = tpe.submit_connected(
-                        self, name, self._get_one_unity_catalog, info, used_schemas
-                    )
-                    futures.append(fut)
             catalogs, exceptions = catch_as_completed(futures)
         return catalogs, exceptions
 
-    def _get_one_unity_catalog(
-        self, info: InformationSchema, schemas: FrozenSet[Tuple[str, str]]
-    ) -> Table:
-        kwargs = {
-            "information_schema": info,
-            "schemas": schemas,
-        }
-        table = self.execute_macro(GET_CATALOG_MACRO_NAME, kwargs=kwargs)
+    def _list_relations_with_information(
+        self, schema_relation: DatabricksRelation
+    ) -> List[Tuple[DatabricksRelation, str]]:
+        results = self._show_table_extended(schema_relation)
 
-        results = self._catalog_filter_table(table, schemas)
-        return results
+        relations: List[Tuple[DatabricksRelation, str]] = []
+        for name, information in results.select(["tableName", "information"]):
+            rel_type = RelationType.View if "Type: VIEW" in information else RelationType.Table
+            relation = self.Relation.create(
+                database=schema_relation.database.lower() if schema_relation.database else None,
+                schema=schema_relation.schema.lower() if schema_relation.schema else None,
+                identifier=name,
+                type=rel_type,
+            )
+            relations.append((relation, information))
 
-    def get_catalog_by_relations(
-        self, used_schemas: FrozenSet[Tuple[str, str]], relations: Set[BaseRelation]
-    ) -> Tuple[Table, List[Exception]]:
-        with executor(self.config) as tpe:
-            relations_by_catalog = self._get_catalog_relations_by_info_schema(relations)
-            futures: List[Future[Table]] = []
+        return relations
 
-            for info_schema, catalog_relations in relations_by_catalog.items():
-                if is_hive_metastore(info_schema.database):
-                    schema_map = defaultdict(list)
-                    for relation in catalog_relations:
-                        schema_map[relation.schema].append(relation)
+    def _show_table_extended(self, schema_relation: DatabricksRelation) -> Table:
+        kwargs = {"schema_relation": schema_relation}
 
-                    for schema, schema_relations in schema_map.items():
-                        table_names = extract_identifiers(schema_relations)
-                        futures.append(
-                            tpe.submit_connected(
-                                self,
-                                "hive_metastore",
-                                self._get_hive_catalog,
-                                schema,
-                                get_identifier_list_string(table_names),
-                            )
-                        )
-                else:
-                    name = ".".join([str(info_schema.database), "information_schema"])
-                    fut = tpe.submit_connected(
-                        self,
-                        name,
-                        self._get_one_catalog_by_relations,
-                        info_schema,
-                        catalog_relations,
-                        used_schemas,
-                    )
-                    futures.append(fut)
+        def exec() -> AttrDict:
+            with self._catalog(schema_relation.database):
+                return self.execute_macro(SHOW_TABLE_EXTENDED_MACRO_NAME, kwargs=kwargs)
 
-            catalogs, exceptions = catch_as_completed(futures)
-        return catalogs, exceptions
+        return Table(
+            handle_missing_objects(exec, AttrDict()),
+            column_names=["schema", "tableName", "isTemporary", "information"],
+        )
 
-    def _get_hive_catalog(self, schema: str, identifier: str) -> Table:
+    def _get_schema_for_catalog(self, catalog: str, schema: str, identifier: str) -> Table:
         columns: List[Dict[str, Any]] = []
 
         if identifier:
             schema_relation = self.Relation.create(
-                database="hive_metastore",
+                database=catalog or "hive_metastore",
                 schema=schema,
                 identifier=identifier,
                 quote_policy=self.config.quoting,
             )
             for relation, information in self._list_relations_with_information(schema_relation):
-                logger.debug("Getting table schema for relation {}", str(relation))
                 columns.extend(self._get_columns_for_catalog(relation, information))
         return Table.from_object(columns, column_types=DEFAULT_TYPE_TESTER)
 
@@ -727,6 +633,8 @@ def get_relation_config(self, relation: DatabricksRelation) -> DatabricksRelatio
             return MaterializedViewAPI.get_from_relation(self, relation)
         elif relation.type == DatabricksRelationType.StreamingTable:
             return StreamingTableAPI.get_from_relation(self, relation)
+        elif relation.type == DatabricksRelationType.Table:
+            return IncrementalTableAPI.get_from_relation(self, relation)
         else:
             raise NotImplementedError(f"Relation type {relation.type} is not supported.")
 
@@ -737,6 +645,8 @@ def get_config_from_model(self, model: RelationConfig) -> DatabricksRelationConf
             return MaterializedViewAPI.get_from_relation_config(model)
         elif model.config.materialized == "streaming_table":
             return StreamingTableAPI.get_from_relation_config(model)
+        elif model.config.materialized == "incremental":
+            return IncrementalTableAPI.get_from_relation_config(model)
         else:
             raise NotImplementedError(
                 f"Materialization {model.config.materialized} is not supported."
@@ -835,3 +745,22 @@ def _describe_relation(
 
         results["show_tblproperties"] = adapter.execute_macro("fetch_tbl_properties", kwargs=kwargs)
         return results
+
+
+class IncrementalTableAPI(RelationAPIBase[IncrementalTableConfig]):
+    relation_type = DatabricksRelationType.Table
+
+    @classmethod
+    def config_type(cls) -> Type[IncrementalTableConfig]:
+        return IncrementalTableConfig
+
+    @classmethod
+    def _describe_relation(
+        cls, adapter: DatabricksAdapter, relation: DatabricksRelation
+    ) -> RelationResults:
+        results = {}
+        kwargs = {"relation": relation}
+
+        if not relation.is_hive_metastore():
+            results["information_schema.tags"] = adapter.execute_macro("fetch_tags", kwargs=kwargs)
+        return results
diff --git a/dbt/adapters/databricks/logging.py b/dbt/adapters/databricks/logging.py
new file mode 100644
index 000000000..4b960c36e
--- /dev/null
+++ b/dbt/adapters/databricks/logging.py
@@ -0,0 +1,29 @@
+import logging
+import os
+from typing import Union
+
+from dbt.adapters.events.logging import AdapterLogger
+
+logger = AdapterLogger("Databricks")
+
+
+class DbtCoreHandler(logging.Handler):
+    def __init__(self, level: Union[str, int], dbt_logger: AdapterLogger):
+        super().__init__(level=level)
+        self.logger = dbt_logger
+
+    def emit(self, record: logging.LogRecord) -> None:
+        # record.levelname will be debug, info, warning, error, or critical
+        # these map 1-to-1 with methods of the AdapterLogger
+        log_func = getattr(self.logger, record.levelname.lower())
+        log_func(record.msg)
+
+
+dbt_adapter_logger = AdapterLogger("databricks-sql-connector")
+
+pysql_logger = logging.getLogger("databricks.sql")
+pysql_logger_level = os.environ.get("DBT_DATABRICKS_CONNECTOR_LOG_LEVEL", "WARN").upper()
+pysql_logger.setLevel(pysql_logger_level)
+
+pysql_handler = DbtCoreHandler(dbt_logger=dbt_adapter_logger, level=pysql_logger_level)
+pysql_logger.addHandler(pysql_handler)
diff --git a/dbt/adapters/databricks/python_submissions.py b/dbt/adapters/databricks/python_submissions.py
index 9b5a18729..2d874fa96 100644
--- a/dbt/adapters/databricks/python_submissions.py
+++ b/dbt/adapters/databricks/python_submissions.py
@@ -1,26 +1,25 @@
-from typing import Any, Dict, Tuple, Optional, Callable
-
-from requests import Session
-
-from dbt.adapters.databricks.__version__ import version
-from dbt.adapters.databricks.connections import DatabricksCredentials, TCredentialProvider
-from dbt.adapters.databricks import utils
-
 import base64
 import time
 import uuid
+from typing import Any
+from typing import Callable
+from typing import Dict
+from typing import Optional
+from typing import Tuple
 
+from dbt_common.exceptions import DbtRuntimeError
+from requests import Session
+from requests.adapters import HTTPAdapter
 from urllib3.util.retry import Retry
 
-from dbt.adapters.events.logging import AdapterLogger
 from dbt.adapters.base import PythonJobHelper
+from dbt.adapters.databricks import utils
+from dbt.adapters.databricks.__version__ import version
+from dbt.adapters.databricks.auth import BearerAuth
+from dbt.adapters.databricks.credentials import DatabricksCredentials
+from dbt.adapters.databricks.credentials import TCredentialProvider
+from dbt.adapters.databricks.logging import logger
 
-from requests.adapters import HTTPAdapter
-from dbt.adapters.databricks.connections import BearerAuth
-from dbt_common.exceptions import DbtRuntimeError
-
-
-logger = AdapterLogger("Databricks")
 
 DEFAULT_POLLING_INTERVAL = 10
 SUBMISSION_LANGUAGE = "python"
diff --git a/dbt/adapters/databricks/relation.py b/dbt/adapters/databricks/relation.py
index 0f25cbcc5..3466f4527 100644
--- a/dbt/adapters/databricks/relation.py
+++ b/dbt/adapters/databricks/relation.py
@@ -1,16 +1,25 @@
-from dataclasses import dataclass, field
-from typing import Any, Dict, Iterable, Optional, Set, Type
+from dataclasses import dataclass
+from dataclasses import field
+from typing import Any
+from typing import Dict
+from typing import Iterable
+from typing import Optional
+from typing import Set
+from typing import Type
+
+from dbt.adapters.base.relation import BaseRelation
+from dbt.adapters.base.relation import InformationSchema
+from dbt.adapters.base.relation import Policy
 from dbt.adapters.contracts.relation import (
     ComponentName,
 )
-from dbt.adapters.base.relation import BaseRelation, Policy, InformationSchema
-from dbt.adapters.spark.impl import KEY_TABLE_OWNER, KEY_TABLE_STATISTICS
-from dbt_common.dataclass_schema import StrEnum
-
 from dbt.adapters.databricks.utils import remove_undefined
-from dbt_common.utils import filter_null_values
+from dbt.adapters.spark.impl import KEY_TABLE_OWNER
+from dbt.adapters.spark.impl import KEY_TABLE_STATISTICS
 from dbt.adapters.utils import classproperty
+from dbt_common.dataclass_schema import StrEnum
 from dbt_common.exceptions import DbtRuntimeError
+from dbt_common.utils import filter_null_values
 
 KEY_TABLE_PROVIDER = "Provider"
 
diff --git a/dbt/adapters/databricks/relation_configs/base.py b/dbt/adapters/databricks/relation_configs/base.py
index bb75c4edf..79cfe9edd 100644
--- a/dbt/adapters/databricks/relation_configs/base.py
+++ b/dbt/adapters/databricks/relation_configs/base.py
@@ -1,10 +1,20 @@
-from abc import ABC, abstractmethod
-from pydantic import BaseModel, ConfigDict
-from typing import Any, ClassVar, Dict, Generic, List, Optional, TypeVar
-from typing_extensions import Self, Type
+from abc import ABC
+from abc import abstractmethod
+from typing import Any
+from typing import ClassVar
+from typing import Dict
+from typing import Generic
+from typing import List
+from typing import Optional
+from typing import TypeVar
+
+from pydantic import BaseModel
+from pydantic import ConfigDict
+from typing_extensions import Self
+from typing_extensions import Type
 
-from dbt.adapters.relation_configs.config_base import RelationResults
 from dbt.adapters.contracts.relation import RelationConfig
+from dbt.adapters.relation_configs.config_base import RelationResults
 
 
 class DatabricksComponentConfig(BaseModel):
diff --git a/dbt/adapters/databricks/relation_configs/comment.py b/dbt/adapters/databricks/relation_configs/comment.py
index 73e7f05f0..bb47cd54a 100644
--- a/dbt/adapters/databricks/relation_configs/comment.py
+++ b/dbt/adapters/databricks/relation_configs/comment.py
@@ -1,10 +1,10 @@
-from typing import Optional, ClassVar
-from dbt.adapters.databricks.relation_configs.base import (
-    DatabricksComponentConfig,
-    DatabricksComponentProcessor,
-)
-from dbt.adapters.relation_configs.config_base import RelationResults
+from typing import ClassVar
+from typing import Optional
+
 from dbt.adapters.contracts.relation import RelationConfig
+from dbt.adapters.databricks.relation_configs.base import DatabricksComponentConfig
+from dbt.adapters.databricks.relation_configs.base import DatabricksComponentProcessor
+from dbt.adapters.relation_configs.config_base import RelationResults
 
 
 class CommentConfig(DatabricksComponentConfig):
diff --git a/dbt/adapters/databricks/relation_configs/incremental.py b/dbt/adapters/databricks/relation_configs/incremental.py
new file mode 100644
index 000000000..5fb786c25
--- /dev/null
+++ b/dbt/adapters/databricks/relation_configs/incremental.py
@@ -0,0 +1,27 @@
+from typing import Dict
+from typing import Optional
+
+from dbt.adapters.databricks.relation_configs.base import DatabricksComponentConfig
+from dbt.adapters.databricks.relation_configs.base import DatabricksRelationChangeSet
+from dbt.adapters.databricks.relation_configs.base import DatabricksRelationConfigBase
+from dbt.adapters.databricks.relation_configs.tags import TagsProcessor
+
+
+class IncrementalTableConfig(DatabricksRelationConfigBase):
+    config_components = [TagsProcessor]
+
+    def get_changeset(
+        self, existing: "IncrementalTableConfig"
+    ) -> Optional[DatabricksRelationChangeSet]:
+        changes: Dict[str, DatabricksComponentConfig] = {}
+
+        for component in self.config_components:
+            key = component.name
+            value = self.config[key]
+            diff = value.get_diff(existing.config[key])
+            if diff:
+                changes[key] = diff
+
+        if len(changes) > 0:
+            return DatabricksRelationChangeSet(changes=changes, requires_full_refresh=False)
+        return None
diff --git a/dbt/adapters/databricks/relation_configs/materialized_view.py b/dbt/adapters/databricks/relation_configs/materialized_view.py
index 4789ede7f..b95b61890 100644
--- a/dbt/adapters/databricks/relation_configs/materialized_view.py
+++ b/dbt/adapters/databricks/relation_configs/materialized_view.py
@@ -1,9 +1,9 @@
-from typing import Dict, Optional
-from dbt.adapters.databricks.relation_configs.base import (
-    DatabricksComponentConfig,
-    DatabricksRelationChangeSet,
-    DatabricksRelationConfigBase,
-)
+from typing import Dict
+from typing import Optional
+
+from dbt.adapters.databricks.relation_configs.base import DatabricksComponentConfig
+from dbt.adapters.databricks.relation_configs.base import DatabricksRelationChangeSet
+from dbt.adapters.databricks.relation_configs.base import DatabricksRelationConfigBase
 from dbt.adapters.databricks.relation_configs.comment import (
     CommentProcessor,
 )
diff --git a/dbt/adapters/databricks/relation_configs/partitioning.py b/dbt/adapters/databricks/relation_configs/partitioning.py
index 78d5f752f..ea8e58b38 100644
--- a/dbt/adapters/databricks/relation_configs/partitioning.py
+++ b/dbt/adapters/databricks/relation_configs/partitioning.py
@@ -1,13 +1,13 @@
 import itertools
-from typing import ClassVar, List, Union
+from typing import ClassVar
+from typing import List
+from typing import Union
 
-from dbt.adapters.relation_configs.config_base import RelationResults
 from dbt.adapters.contracts.relation import RelationConfig
 from dbt.adapters.databricks.relation_configs import base
-from dbt.adapters.databricks.relation_configs.base import (
-    DatabricksComponentConfig,
-    DatabricksComponentProcessor,
-)
+from dbt.adapters.databricks.relation_configs.base import DatabricksComponentConfig
+from dbt.adapters.databricks.relation_configs.base import DatabricksComponentProcessor
+from dbt.adapters.relation_configs.config_base import RelationResults
 
 
 class PartitionedByConfig(DatabricksComponentConfig):
diff --git a/dbt/adapters/databricks/relation_configs/query.py b/dbt/adapters/databricks/relation_configs/query.py
index 46df52be6..469a117c6 100644
--- a/dbt/adapters/databricks/relation_configs/query.py
+++ b/dbt/adapters/databricks/relation_configs/query.py
@@ -1,12 +1,12 @@
 from typing import ClassVar
-from dbt.adapters.relation_configs.config_base import RelationResults
-from dbt.adapters.contracts.relation import RelationConfig
-from dbt.adapters.databricks.relation_configs.base import (
-    DatabricksComponentConfig,
-    DatabricksComponentProcessor,
-)
+
 from dbt_common.exceptions import DbtRuntimeError
 
+from dbt.adapters.contracts.relation import RelationConfig
+from dbt.adapters.databricks.relation_configs.base import DatabricksComponentConfig
+from dbt.adapters.databricks.relation_configs.base import DatabricksComponentProcessor
+from dbt.adapters.relation_configs.config_base import RelationResults
+
 
 class QueryConfig(DatabricksComponentConfig):
     """Component encapsulating the query that defines a relation."""
diff --git a/dbt/adapters/databricks/relation_configs/refresh.py b/dbt/adapters/databricks/relation_configs/refresh.py
index 7e0b651c5..c3637297c 100644
--- a/dbt/adapters/databricks/relation_configs/refresh.py
+++ b/dbt/adapters/databricks/relation_configs/refresh.py
@@ -1,14 +1,14 @@
 import re
-from typing import ClassVar, Optional
+from typing import ClassVar
+from typing import Optional
 
-from dbt.adapters.relation_configs.config_base import RelationResults
 from dbt_common.exceptions import DbtRuntimeError
+
 from dbt.adapters.contracts.relation import RelationConfig
 from dbt.adapters.databricks.relation_configs import base
-from dbt.adapters.databricks.relation_configs.base import (
-    DatabricksComponentConfig,
-    DatabricksComponentProcessor,
-)
+from dbt.adapters.databricks.relation_configs.base import DatabricksComponentConfig
+from dbt.adapters.databricks.relation_configs.base import DatabricksComponentProcessor
+from dbt.adapters.relation_configs.config_base import RelationResults
 
 SCHEDULE_REGEX = re.compile(r"CRON '(.*)' AT TIME ZONE '(.*)'")
 
diff --git a/dbt/adapters/databricks/relation_configs/streaming_table.py b/dbt/adapters/databricks/relation_configs/streaming_table.py
index e7e24b995..7c00d549c 100644
--- a/dbt/adapters/databricks/relation_configs/streaming_table.py
+++ b/dbt/adapters/databricks/relation_configs/streaming_table.py
@@ -1,19 +1,17 @@
-from typing import Dict, Optional
-from dbt.adapters.databricks.relation_configs.base import (
-    DatabricksComponentConfig,
-    DatabricksRelationChangeSet,
-    DatabricksRelationConfigBase,
-)
+from typing import Dict
+from typing import Optional
+
+from dbt.adapters.databricks.relation_configs.base import DatabricksComponentConfig
+from dbt.adapters.databricks.relation_configs.base import DatabricksRelationChangeSet
+from dbt.adapters.databricks.relation_configs.base import DatabricksRelationConfigBase
 from dbt.adapters.databricks.relation_configs.comment import (
     CommentProcessor,
 )
 from dbt.adapters.databricks.relation_configs.partitioning import (
     PartitionedByProcessor,
 )
-from dbt.adapters.databricks.relation_configs.refresh import (
-    RefreshConfig,
-    RefreshProcessor,
-)
+from dbt.adapters.databricks.relation_configs.refresh import RefreshConfig
+from dbt.adapters.databricks.relation_configs.refresh import RefreshProcessor
 from dbt.adapters.databricks.relation_configs.tblproperties import (
     TblPropertiesProcessor,
 )
diff --git a/dbt/adapters/databricks/relation_configs/tags.py b/dbt/adapters/databricks/relation_configs/tags.py
new file mode 100644
index 000000000..3a53728a2
--- /dev/null
+++ b/dbt/adapters/databricks/relation_configs/tags.py
@@ -0,0 +1,51 @@
+from typing import ClassVar
+from typing import Dict
+from typing import List
+from typing import Optional
+
+from dbt.adapters.contracts.relation import RelationConfig
+from dbt.adapters.databricks.relation_configs import base
+from dbt.adapters.databricks.relation_configs.base import DatabricksComponentConfig
+from dbt.adapters.databricks.relation_configs.base import DatabricksComponentProcessor
+from dbt.adapters.relation_configs.config_base import RelationResults
+from dbt_common.exceptions import DbtRuntimeError
+
+
+class TagsConfig(DatabricksComponentConfig):
+    """Component encapsulating the tblproperties of a relation."""
+
+    set_tags: Dict[str, str]
+    unset_tags: List[str] = []
+
+    def get_diff(self, other: "TagsConfig") -> Optional["TagsConfig"]:
+        to_unset = []
+        for k in other.set_tags.keys():
+            if k not in self.set_tags:
+                to_unset.append(k)
+        return TagsConfig(set_tags=self.set_tags, unset_tags=to_unset)
+
+
+class TagsProcessor(DatabricksComponentProcessor[TagsConfig]):
+    name: ClassVar[str] = "tags"
+
+    @classmethod
+    def from_relation_results(cls, results: RelationResults) -> TagsConfig:
+        table = results.get("information_schema.tags")
+        tags = dict()
+
+        if table:
+            for row in table.rows:
+                tags[str(row[0])] = str(row[1])
+
+        return TagsConfig(set_tags=tags)
+
+    @classmethod
+    def from_relation_config(cls, relation_config: RelationConfig) -> TagsConfig:
+        tags = base.get_config_value(relation_config, "databricks_tags")
+        if not tags:
+            return TagsConfig(set_tags=dict())
+        if isinstance(tags, Dict):
+            tags = {str(k): str(v) for k, v in tags.items()}
+            return TagsConfig(set_tags=tags)
+        else:
+            raise DbtRuntimeError("databricks_tags must be a dictionary")
diff --git a/dbt/adapters/databricks/relation_configs/tblproperties.py b/dbt/adapters/databricks/relation_configs/tblproperties.py
index 4b48595b2..e54140f71 100644
--- a/dbt/adapters/databricks/relation_configs/tblproperties.py
+++ b/dbt/adapters/databricks/relation_configs/tblproperties.py
@@ -1,12 +1,15 @@
-from typing import Any, Dict, ClassVar, List
+from typing import Any
+from typing import ClassVar
+from typing import Dict
+from typing import List
+
+from dbt_common.exceptions import DbtRuntimeError
+
+from dbt.adapters.contracts.relation import RelationConfig
 from dbt.adapters.databricks.relation_configs import base
-from dbt.adapters.databricks.relation_configs.base import (
-    DatabricksComponentConfig,
-    DatabricksComponentProcessor,
-)
+from dbt.adapters.databricks.relation_configs.base import DatabricksComponentConfig
+from dbt.adapters.databricks.relation_configs.base import DatabricksComponentProcessor
 from dbt.adapters.relation_configs.config_base import RelationResults
-from dbt.adapters.contracts.relation import RelationConfig
-from dbt_common.exceptions import DbtRuntimeError
 
 
 class TblPropertiesConfig(DatabricksComponentConfig):
diff --git a/dbt/adapters/databricks/utils.py b/dbt/adapters/databricks/utils.py
index 95258c925..fe70aae01 100644
--- a/dbt/adapters/databricks/utils.py
+++ b/dbt/adapters/databricks/utils.py
@@ -1,11 +1,17 @@
 import functools
 import inspect
 import re
-from typing import Any, Callable, Type, TypeVar
-from agate import Table, Row
-from dbt.adapters.base import BaseAdapter
+from typing import Any
+from typing import Callable
+from typing import Type
+from typing import TypeVar
+
+from agate import Row
+from agate import Table
 from jinja2.runtime import Undefined
 
+from dbt.adapters.base import BaseAdapter
+
 
 A = TypeVar("A", bound=BaseAdapter)
 
diff --git a/dbt/include/databricks/macros/adapters/catalog.sql b/dbt/include/databricks/macros/adapters/catalog.sql
index bb889178f..4d380d549 100644
--- a/dbt/include/databricks/macros/adapters/catalog.sql
+++ b/dbt/include/databricks/macros/adapters/catalog.sql
@@ -94,4 +94,4 @@
             {%- if not loop.last %} or {% endif -%}
         {%- endfor -%}
     )
-{%- endmacro %}
\ No newline at end of file
+{%- endmacro %}
diff --git a/dbt/include/databricks/macros/adapters/databricks_catalog.sql b/dbt/include/databricks/macros/adapters/databricks_catalog.sql
index 23f4ca79d..4cfd1c7ac 100644
--- a/dbt/include/databricks/macros/adapters/databricks_catalog.sql
+++ b/dbt/include/databricks/macros/adapters/databricks_catalog.sql
@@ -17,4 +17,4 @@
   {% call statement() %}
     use catalog {{ adapter.quote(catalog) }}
   {% endcall %}
-{% endmacro %}
\ No newline at end of file
+{% endmacro %}
diff --git a/dbt/include/databricks/macros/adapters/metadata.sql b/dbt/include/databricks/macros/adapters/metadata.sql
index dc5a5591e..8e1fb2895 100644
--- a/dbt/include/databricks/macros/adapters/metadata.sql
+++ b/dbt/include/databricks/macros/adapters/metadata.sql
@@ -73,9 +73,9 @@
 
 {% macro get_view_description(relation) %}
   {% call statement('get_view_description', fetch_result=True) -%}
-    select * 
-    from {{ relation.information_schema() }}.`views` 
-    where table_schema = '{{ relation.schema }}' 
+    select *
+    from {{ relation.information_schema() }}.`views`
+    where table_schema = '{{ relation.schema }}'
       and table_name = '{{ relation.identifier }}'
   {%- endcall -%}
 
@@ -92,4 +92,58 @@
   {% endcall %}
 
   {% do return(load_result('get_view_description_alt').table) %}
+{% endmacro %}
+
+
+{% macro get_uc_tables_with_columns(relation) %}
+  {% call statement('get_uc_tables_with_columns', fetch_result=True) -%}
+    with tables as (
+      select
+        table_name,
+        comment,
+        if(table_type = 'EXTERNAL' or table_type = 'MANAGED', 'table', lower(table_type)) as table_type,
+        lower(data_source_format) as file_format,
+        table_owner
+      from `{{ relation.database }}`.`information_schema`.`tables`
+      where table_schema = '{{ relation.schema }}'
+      {% if relation.identifier %}
+        and table_name = '{{ relation.identifier }}'
+      {% endif %}
+    ),
+    columns as (
+      select
+        table_name,
+        to_json(collect_list(array(column_name, data_type, comment))) as columns
+      from `{{ relation.database }}`.`information_schema`.`columns`
+      where table_schema = '{{ relation.schema }}'
+      {% if relation.identifier %}
+        and table_name = '{{ relation.identifier }}'
+      {% endif %}
+      group by table_name
+    )
+    select
+      tables.*,
+      columns.columns
+    from tables
+    left join columns using(table_name)
+  {% endcall %}
+
+  {% do return(load_result('get_uc_tables_with_columns').table) %}
+{% endmacro %}
+
+{% macro get_uc_tables(relation) %}
+  {% call statement('get_uc_tables', fetch_result=True) -%}
+    select
+      table_name,
+      if(table_type = 'EXTERNAL' or table_type = 'MANAGED', 'table', lower(table_type)) as table_type,
+      lower(data_source_format) as file_format,
+      table_owner
+    from `{{ relation.database }}`.`information_schema`.`tables`
+    where table_schema = '{{ relation.schema }}'
+    {% if relation.identifier %}
+      and table_name = '{{ relation.identifier }}'
+    {% endif %}
+  {% endcall %}
+
+  {% do return(load_result('get_uc_tables').table) %}
 {% endmacro %}
\ No newline at end of file
diff --git a/dbt/include/databricks/macros/adapters/persist_docs.sql b/dbt/include/databricks/macros/adapters/persist_docs.sql
index 3ebeee599..581555e84 100644
--- a/dbt/include/databricks/macros/adapters/persist_docs.sql
+++ b/dbt/include/databricks/macros/adapters/persist_docs.sql
@@ -17,7 +17,7 @@
   {% call statement('get_columns_comments', fetch_result=True) -%}
     describe table {{ relation }}
   {% endcall %}
-  
+
   {% do return(load_result('get_columns_comments').table) %}
 {% endmacro %}
 
@@ -43,4 +43,4 @@
     {{ get_column_comment_sql(column_name, model_columns) }}
     {{- ", " if not loop.last else "" }}
   {% endfor %}
-{% endmacro %}
\ No newline at end of file
+{% endmacro %}
diff --git a/dbt/include/databricks/macros/adapters/python.sql b/dbt/include/databricks/macros/adapters/python.sql
index 89a4fdbf4..dc24ec119 100644
--- a/dbt/include/databricks/macros/adapters/python.sql
+++ b/dbt/include/databricks/macros/adapters/python.sql
@@ -14,7 +14,7 @@ import pyspark
 # preferentially convert pandas DataFrames to pandas-on-Spark or Koalas DataFrames first
 # since they know how to convert pandas DataFrames better than `spark.createDataFrame(df)`
 # and converting from pandas-on-Spark to Spark DataFrame has no overhead
-  
+
 if pandas_available and isinstance(df, pandas.core.frame.DataFrame):
     if pyspark_pandas_api_available:
         df = pyspark.pandas.frame.DataFrame(df)
diff --git a/dbt/include/databricks/macros/adapters/relation.sql b/dbt/include/databricks/macros/adapters/relation.sql
index c348b5678..1f8af0830 100644
--- a/dbt/include/databricks/macros/adapters/relation.sql
+++ b/dbt/include/databricks/macros/adapters/relation.sql
@@ -30,4 +30,4 @@
       type=type
   ) -%}
   {% do return([false, new_relation]) %}
-{% endmacro %}
\ No newline at end of file
+{% endmacro %}
diff --git a/dbt/include/databricks/macros/get_custom_name/get_custom_database.sql b/dbt/include/databricks/macros/get_custom_name/get_custom_database.sql
index 4ebbad806..736c26ce0 100644
--- a/dbt/include/databricks/macros/get_custom_name/get_custom_database.sql
+++ b/dbt/include/databricks/macros/get_custom_name/get_custom_database.sql
@@ -1,4 +1,4 @@
-{# 
+{#
     This is identical to the implementation in dbt-core.
     We need to override because dbt-spark overrides to something we don't like.
 #}
@@ -10,4 +10,4 @@
     {%- else -%}
         {{ return(custom_database_name) }}
     {%- endif -%}
-{%- endmacro %}
\ No newline at end of file
+{%- endmacro %}
diff --git a/dbt/include/databricks/macros/materializations/clone.sql b/dbt/include/databricks/macros/materializations/clone.sql
index 470879047..74cb11fdf 100644
--- a/dbt/include/databricks/macros/materializations/clone.sql
+++ b/dbt/include/databricks/macros/materializations/clone.sql
@@ -69,4 +69,4 @@
       {{ return(relations) }}
   {% endif %}
 
-{%- endmaterialization -%}
\ No newline at end of file
+{%- endmaterialization -%}
diff --git a/dbt/include/databricks/macros/materializations/incremental/incremental.sql b/dbt/include/databricks/macros/materializations/incremental/incremental.sql
index e20f3569c..059230861 100644
--- a/dbt/include/databricks/macros/materializations/incremental/incremental.sql
+++ b/dbt/include/databricks/macros/materializations/incremental/incremental.sql
@@ -3,6 +3,8 @@
   {%- set raw_file_format = config.get('file_format', default='delta') -%}
   {%- set raw_strategy = config.get('incremental_strategy') or 'merge' -%}
   {%- set grant_config = config.get('grants') -%}
+  {%- set tblproperties = config.get('tblproperties') -%}
+  {%- set tags = config.get('databricks_tags') -%}
 
   {%- set file_format = dbt_databricks_validate_get_file_format(raw_file_format) -%}
   {%- set incremental_strategy = dbt_databricks_validate_get_incremental_strategy(raw_strategy, file_format) -%}
@@ -14,7 +16,7 @@
   {%- set partition_by = config.get('partition_by', none) -%}
   {%- set language = model['language'] -%}
   {%- set on_schema_change = incremental_validate_on_schema_change(config.get('on_schema_change'), default='ignore') -%}
-  {%- set target_relation = this -%}
+  {%- set target_relation = this.incorporate(type='table') -%}
   {%- set existing_relation = adapter.get_relation(database=this.database, schema=this.schema, identifier=this.identifier, needs_information=True) -%}
 
   {#-- Run pre-hooks --#}
@@ -27,6 +29,7 @@
       {{ create_table_as(False, target_relation, compiled_code, language) }}
     {%- endcall -%}
     {% do persist_constraints(target_relation, model) %}
+    {% do apply_tags(target_relation, tags) %}
   {%- elif existing_relation.is_view or existing_relation.is_materialized_view or existing_relation.is_streaming_table or should_full_refresh() -%}
     {#-- Relation must be dropped & recreated --#}
     {% set is_delta = (file_format == 'delta' and existing_relation.is_delta) %}
@@ -40,8 +43,12 @@
     {% if not existing_relation.is_view %}
       {% do persist_constraints(target_relation, model) %}
     {% endif %}
+    {% do apply_tags(target_relation, tags) %}
   {%- else -%}
     {#-- Relation must be merged --#}
+    {%- set _existing_config = adapter.get_relation_config(existing_relation) -%}
+    {%- set model_config = adapter.get_config_from_model(config.model) -%}
+    {%- set _configuration_changes = model_config.get_changeset(_existing_config) -%}
     {%- set temp_relation = databricks__make_temp_relation(target_relation, as_table=language != 'sql') -%}
     {%- call statement('create_temp_relation', language=language) -%}
       {{ create_table_as(True, temp_relation, compiled_code, language) }}
@@ -71,11 +78,17 @@
       Also, why does not either drop_relation or adapter.drop_relation work here?!
       --#}
     {%- endif -%}
+    {% if _configuration_changes is not none %}
+      {% set tags = _configuration_changes.changes["tags"] %}
+      {% if tags is not none %}
+        {% do apply_tags(target_relation, tags.set_tags, tags.unset_tags) %}
+      {%- endif -%}
+    {%- endif -%}
   {%- endif -%}
 
   {% set should_revoke = should_revoke(existing_relation, full_refresh_mode) %}
   {% do apply_grants(target_relation, grant_config, should_revoke) %}
-
+  {% do apply_tblproperties_python(target_relation, tblproperties, language) %}
   {% do persist_docs(target_relation, model) %}
   {% do optimize(target_relation) %}
 
diff --git a/dbt/include/databricks/macros/materializations/incremental/strategies.sql b/dbt/include/databricks/macros/materializations/incremental/strategies.sql
index d73b6a8e1..426066ba1 100644
--- a/dbt/include/databricks/macros/materializations/incremental/strategies.sql
+++ b/dbt/include/databricks/macros/materializations/incremental/strategies.sql
@@ -45,7 +45,7 @@
       {% endif %}
     {% endif %}
     table {{ temp_relation }}
-        
+
 {% endmacro %}
 
 {% macro get_insert_into_sql(source_relation, target_relation) %}
diff --git a/dbt/include/databricks/macros/materializations/materialized_view.sql b/dbt/include/databricks/macros/materializations/materialized_view.sql
index 869f52d7e..ecbd8e73b 100644
--- a/dbt/include/databricks/macros/materializations/materialized_view.sql
+++ b/dbt/include/databricks/macros/materializations/materialized_view.sql
@@ -95,4 +95,4 @@
 
     {{ run_hooks(post_hooks, inside_transaction=True) }}
 
-{% endmacro %}
\ No newline at end of file
+{% endmacro %}
diff --git a/dbt/include/databricks/macros/materializations/seeds/seeds.sql b/dbt/include/databricks/macros/materializations/seeds/seeds.sql
index 5faad2011..a2b2431fd 100644
--- a/dbt/include/databricks/macros/materializations/seeds/seeds.sql
+++ b/dbt/include/databricks/macros/materializations/seeds/seeds.sql
@@ -60,4 +60,4 @@
 
   {{ return({'relations': [target_relation]}) }}
 
-{% endmaterialization %}
\ No newline at end of file
+{% endmaterialization %}
diff --git a/dbt/include/databricks/macros/materializations/streaming_table.sql b/dbt/include/databricks/macros/materializations/streaming_table.sql
index 2a5916fec..57ab99a6b 100644
--- a/dbt/include/databricks/macros/materializations/streaming_table.sql
+++ b/dbt/include/databricks/macros/materializations/streaming_table.sql
@@ -94,4 +94,4 @@
 
     {{ run_hooks(post_hooks, inside_transaction=True) }}
 
-{% endmacro %}
\ No newline at end of file
+{% endmacro %}
diff --git a/dbt/include/databricks/macros/materializations/table.sql b/dbt/include/databricks/macros/materializations/table.sql
index c7c1572ec..d7de6425a 100644
--- a/dbt/include/databricks/macros/materializations/table.sql
+++ b/dbt/include/databricks/macros/materializations/table.sql
@@ -3,6 +3,8 @@
   {%- set language = model['language'] -%}
   {%- set identifier = model['alias'] -%}
   {%- set grant_config = config.get('grants') -%}
+  {%- set tblproperties = config.get('tblproperties') -%}
+  {%- set tags = config.get('databricks_tags') -%}
 
   {%- set old_relation = adapter.get_relation(database=database, schema=schema, identifier=identifier, needs_information=True) -%}
   {%- set target_relation = api.Relation.create(identifier=identifier,
@@ -27,7 +29,10 @@
 
   {% set should_revoke = should_revoke(old_relation, full_refresh_mode=True) %}
   {% do apply_grants(target_relation, grant_config, should_revoke) %}
+  {% do apply_tblproperties_python(target_relation, tblproperties, language) %}
 
+  {%- do apply_tags(target_relation, tags) -%}
+  
   {% do persist_docs(target_relation, model) %}
 
   {% do persist_constraints(target_relation, model) %}
diff --git a/dbt/include/databricks/macros/materializations/view.sql b/dbt/include/databricks/macros/materializations/view.sql
index 19d6749d1..8c062edf3 100644
--- a/dbt/include/databricks/macros/materializations/view.sql
+++ b/dbt/include/databricks/macros/materializations/view.sql
@@ -8,6 +8,7 @@
       identifier=identifier, schema=schema, database=database,
       type='view') -%}
   {% set grant_config = config.get('grants') %}
+  {% set tags = config.get('databricks_tags') %}
 
   {{ run_hooks(pre_hooks) }}
 
@@ -26,8 +27,10 @@
   {% set should_revoke = should_revoke(exists_as_view, full_refresh_mode=True) %}
   {% do apply_grants(target_relation, grant_config, should_revoke=True) %}
 
+  {%- do apply_tags(target_relation, tags) -%}
+
   {{ run_hooks(post_hooks) }}
 
   {{ return({'relations': [target_relation]}) }}
 
-{%- endmaterialization %}
\ No newline at end of file
+{%- endmaterialization %}
diff --git a/dbt/include/databricks/macros/relations/components/comment.sql b/dbt/include/databricks/macros/relations/components/comment.sql
index 86f26a6b0..e0ec489b9 100644
--- a/dbt/include/databricks/macros/relations/components/comment.sql
+++ b/dbt/include/databricks/macros/relations/components/comment.sql
@@ -2,4 +2,4 @@
 {% if comment is string -%}
   COMMENT '{{ comment }}'
 {%- endif -%}
-{%- endmacro -%}
\ No newline at end of file
+{%- endmacro -%}
diff --git a/dbt/include/databricks/macros/relations/components/partitioning.sql b/dbt/include/databricks/macros/relations/components/partitioning.sql
index a5597f719..b59073609 100644
--- a/dbt/include/databricks/macros/relations/components/partitioning.sql
+++ b/dbt/include/databricks/macros/relations/components/partitioning.sql
@@ -2,4 +2,4 @@
 {%- if partition_by -%}
   PARTITIONED BY ({%- for col in partition_by -%}{{ col }}{% if not loop.last %}, {% endif %}{%- endfor %})
 {%- endif -%}
-{%- endmacro %}
\ No newline at end of file
+{%- endmacro %}
diff --git a/dbt/include/databricks/macros/relations/components/refresh_schedule.sql b/dbt/include/databricks/macros/relations/components/refresh_schedule.sql
index 618c4a3c3..11f459f6a 100644
--- a/dbt/include/databricks/macros/relations/components/refresh_schedule.sql
+++ b/dbt/include/databricks/macros/relations/components/refresh_schedule.sql
@@ -14,4 +14,4 @@
   {%- else -%}
     DROP SCHEDULE
   {%- endif -%}
-{% endmacro %}
\ No newline at end of file
+{% endmacro %}
diff --git a/dbt/include/databricks/macros/relations/components/tblproperties.sql b/dbt/include/databricks/macros/relations/components/tblproperties.sql
index 7e6c95faf..bf19bd7a1 100644
--- a/dbt/include/databricks/macros/relations/components/tblproperties.sql
+++ b/dbt/include/databricks/macros/relations/components/tblproperties.sql
@@ -6,4 +6,4 @@
     {% endfor -%}
     )
   {%- endif -%}
-{% endmacro %}
\ No newline at end of file
+{% endmacro %}
diff --git a/dbt/include/databricks/macros/relations/constraints.sql b/dbt/include/databricks/macros/relations/constraints.sql
index f8de57b32..e3ec7d895 100644
--- a/dbt/include/databricks/macros/relations/constraints.sql
+++ b/dbt/include/databricks/macros/relations/constraints.sql
@@ -87,7 +87,7 @@
         {% if statement %}
           {% do statements.append(statement) %}
         {% endif %}
-      {% endfor %}  
+      {% endfor %}
     {% endif %}
   {% endfor %}
 
@@ -187,7 +187,7 @@
       {% set joined_names = quoted_names|join(", ") %}
 
       {% set parent = constraint.get("parent") %}
-      {% if not parent %} 
+      {% if not parent %}
         {{ exceptions.raise_compiler_error('No parent table defined for foreign key: ' ~ expression) }}
       {% endif %}
       {% if not "." in parent %}
diff --git a/dbt/include/databricks/macros/relations/create.sql b/dbt/include/databricks/macros/relations/create.sql
index 1d94d976f..fa96d19b6 100644
--- a/dbt/include/databricks/macros/relations/create.sql
+++ b/dbt/include/databricks/macros/relations/create.sql
@@ -16,4 +16,4 @@
 
     {%- endif -%}
 
-{%- endmacro -%}
\ No newline at end of file
+{%- endmacro -%}
diff --git a/dbt/include/databricks/macros/relations/drop.sql b/dbt/include/databricks/macros/relations/drop.sql
index d0e688d44..464ac51d2 100644
--- a/dbt/include/databricks/macros/relations/drop.sql
+++ b/dbt/include/databricks/macros/relations/drop.sql
@@ -2,7 +2,7 @@
     {%- if relation.is_materialized_view -%}
         {{ drop_materialized_view(relation) }}
     {%- elif relation.is_streaming_table-%}
-        {{ drop_streaming_table(relation) }}   
+        {{ drop_streaming_table(relation) }}
     {%- elif relation.is_view -%}
         {{ drop_view(relation) }}
     {%- else -%}
@@ -14,4 +14,4 @@
     {% call statement('drop_relation', auto_begin=False) -%}
         {{ get_drop_sql(relation) }}
     {%- endcall %}
-{% endmacro %}
\ No newline at end of file
+{% endmacro %}
diff --git a/dbt/include/databricks/macros/relations/file_format.sql b/dbt/include/databricks/macros/relations/file_format.sql
index 7e7ce98b9..ac238c1e5 100644
--- a/dbt/include/databricks/macros/relations/file_format.sql
+++ b/dbt/include/databricks/macros/relations/file_format.sql
@@ -1,4 +1,4 @@
 {% macro file_format_clause() %}
   {%- set file_format = config.get('file_format', default='delta') -%}
   using {{ file_format }}
-{%- endmacro -%}
\ No newline at end of file
+{%- endmacro -%}
diff --git a/dbt/include/databricks/macros/relations/location.sql b/dbt/include/databricks/macros/relations/location.sql
index 84576eafa..f18a94472 100644
--- a/dbt/include/databricks/macros/relations/location.sql
+++ b/dbt/include/databricks/macros/relations/location.sql
@@ -9,4 +9,4 @@
         'Incompatible configuration: `location_root` must be set when using a non-delta file format with Unity Catalog'
     ) }}
   {%- endif %}
-{%- endmacro -%}
\ No newline at end of file
+{%- endmacro -%}
diff --git a/dbt/include/databricks/macros/relations/materialized_view/alter.sql b/dbt/include/databricks/macros/relations/materialized_view/alter.sql
index 97614cb11..41d9bed06 100644
--- a/dbt/include/databricks/macros/relations/materialized_view/alter.sql
+++ b/dbt/include/databricks/macros/relations/materialized_view/alter.sql
@@ -48,4 +48,4 @@
     -- Currently only schedule can be altered
     ALTER MATERIALIZED VIEW {{ relation }}
         {{ get_alter_sql_refresh_schedule(refresh.cron, refresh.time_zone_value, refresh.is_altered) -}}
-{% endmacro %}
\ No newline at end of file
+{% endmacro %}
diff --git a/dbt/include/databricks/macros/relations/materialized_view/create.sql b/dbt/include/databricks/macros/relations/materialized_view/create.sql
index 4ec7b27f7..9f5c13559 100644
--- a/dbt/include/databricks/macros/relations/materialized_view/create.sql
+++ b/dbt/include/databricks/macros/relations/materialized_view/create.sql
@@ -11,4 +11,4 @@
     {{ get_create_sql_refresh_schedule(refresh.cron, refresh.time_zone_value) }}
   as
     {{ sql }}
-{% endmacro %}
\ No newline at end of file
+{% endmacro %}
diff --git a/dbt/include/databricks/macros/relations/materialized_view/drop.sql b/dbt/include/databricks/macros/relations/materialized_view/drop.sql
index 69aa0236c..f3774119d 100644
--- a/dbt/include/databricks/macros/relations/materialized_view/drop.sql
+++ b/dbt/include/databricks/macros/relations/materialized_view/drop.sql
@@ -1,3 +1,3 @@
 {% macro databricks__drop_materialized_view(relation) -%}
     drop materialized view if exists {{ relation }}
-{%- endmacro %}
\ No newline at end of file
+{%- endmacro %}
diff --git a/dbt/include/databricks/macros/relations/materialized_view/refresh.sql b/dbt/include/databricks/macros/relations/materialized_view/refresh.sql
index 651b3082d..10a8346be 100644
--- a/dbt/include/databricks/macros/relations/materialized_view/refresh.sql
+++ b/dbt/include/databricks/macros/relations/materialized_view/refresh.sql
@@ -1,3 +1,3 @@
 {% macro databricks__refresh_materialized_view(relation) -%}
   refresh materialized view {{ relation }}
-{% endmacro %}
\ No newline at end of file
+{% endmacro %}
diff --git a/dbt/include/databricks/macros/relations/optimize.sql b/dbt/include/databricks/macros/relations/optimize.sql
index 8540caf2d..79f001646 100644
--- a/dbt/include/databricks/macros/relations/optimize.sql
+++ b/dbt/include/databricks/macros/relations/optimize.sql
@@ -3,8 +3,8 @@
 {% endmacro %}
 
 {%- macro databricks__optimize(relation) -%}
-  {%- if var('DATABRICKS_SKIP_OPTIMIZE', 'false')|lower != 'true' and 
-        var('databricks_skip_optimize', 'false')|lower != 'true' and 
+  {%- if var('DATABRICKS_SKIP_OPTIMIZE', 'false')|lower != 'true' and
+        var('databricks_skip_optimize', 'false')|lower != 'true' and
         config.get('file_format', 'delta') == 'delta' -%}
     {%- if (config.get('zorder', False) or config.get('liquid_clustered_by', False)) -%}
       {%- call statement('run_optimize_stmt') -%}
@@ -33,4 +33,4 @@
       {%- endif %}
     {%- endif %}
   {%- endif %}
-{%- endmacro -%}
\ No newline at end of file
+{%- endmacro -%}
diff --git a/dbt/include/databricks/macros/relations/replace.sql b/dbt/include/databricks/macros/relations/replace.sql
index ae788a07b..71637df87 100644
--- a/dbt/include/databricks/macros/relations/replace.sql
+++ b/dbt/include/databricks/macros/relations/replace.sql
@@ -44,9 +44,9 @@
     {# /* no renaming is allowed, so just drop and create */ #}
     {%- else -%}
         {{ return([
-            get_drop_sql(existing_relation), 
+            get_drop_sql(existing_relation),
             get_create_sql(target_relation, sql)
         ]) }}
     {%- endif -%}
 
-{% endmacro %}
\ No newline at end of file
+{% endmacro %}
diff --git a/dbt/include/databricks/macros/relations/streaming_table/alter.sql b/dbt/include/databricks/macros/relations/streaming_table/alter.sql
index 1483f0461..03f15a502 100644
--- a/dbt/include/databricks/macros/relations/streaming_table/alter.sql
+++ b/dbt/include/databricks/macros/relations/streaming_table/alter.sql
@@ -80,4 +80,4 @@
     ALTER STREAMING TABLE {{ relation }}
         {{ get_alter_sql_refresh_schedule(refresh.cron, refresh.time_zone_value, False) -}}
   {%- endif -%}
-{% endmacro %}
\ No newline at end of file
+{% endmacro %}
diff --git a/dbt/include/databricks/macros/relations/streaming_table/drop.sql b/dbt/include/databricks/macros/relations/streaming_table/drop.sql
index 88c95c2ae..c8e0cd839 100644
--- a/dbt/include/databricks/macros/relations/streaming_table/drop.sql
+++ b/dbt/include/databricks/macros/relations/streaming_table/drop.sql
@@ -4,4 +4,4 @@
 
 {% macro default__drop_streaming_table(relation) -%}
     drop table if exists {{ relation }}
-{%- endmacro %}
\ No newline at end of file
+{%- endmacro %}
diff --git a/dbt/include/databricks/macros/relations/table/create.sql b/dbt/include/databricks/macros/relations/table/create.sql
index 000500acb..ac5cdcf42 100644
--- a/dbt/include/databricks/macros/relations/table/create.sql
+++ b/dbt/include/databricks/macros/relations/table/create.sql
@@ -76,4 +76,4 @@
     {%- endfor -%}
     )
   {%- endif %}
-{%- endmacro -%}
\ No newline at end of file
+{%- endmacro -%}
diff --git a/dbt/include/databricks/macros/relations/table/drop.sql b/dbt/include/databricks/macros/relations/table/drop.sql
index 968c61420..3a7d0ced0 100644
--- a/dbt/include/databricks/macros/relations/table/drop.sql
+++ b/dbt/include/databricks/macros/relations/table/drop.sql
@@ -1,3 +1,3 @@
 {% macro databricks__drop_table(relation) -%}
     drop table if exists {{ relation }}
-{%- endmacro %}
\ No newline at end of file
+{%- endmacro %}
diff --git a/dbt/include/databricks/macros/relations/tags.sql b/dbt/include/databricks/macros/relations/tags.sql
new file mode 100644
index 000000000..eaa217db8
--- /dev/null
+++ b/dbt/include/databricks/macros/relations/tags.sql
@@ -0,0 +1,47 @@
+{% macro fetch_tags(relation) -%}
+  {% if relation.is_hive_metastore() %}
+    {{ exceptions.raise_compiler_error("Tags are only supported for Unity Catalog") }}
+  {%- endif %}
+  {% call statement('list_tags', fetch_result=True) -%}
+    {{ fetch_tags_sql(relation) }}
+  {% endcall %}
+  {% do return(load_result('list_tags').table) %}
+{%- endmacro -%}
+
+{% macro fetch_tags_sql(relation) -%}
+  SELECT tag_name, tag_value
+  FROM `{{ relation.database }}`.`information_schema`.`table_tags`
+  WHERE schema_name = '{{ relation.schema }}' AND table_name = '{{ relation.identifier }}'
+{%- endmacro -%}
+
+{% macro apply_tags(relation, set_tags, unset_tags=[]) -%}
+  {%- if (set_tags or unset_tags) and relation.is_hive_metastore() -%}
+    {{ exceptions.raise_compiler_error("Tags are only supported for Unity Catalog") }}
+  {%- endif -%}
+  {%- if set_tags %}
+    {%- call statement('set_tags') -%}
+       {{ alter_set_tags(relation, set_tags) }}
+    {%- endcall -%}
+  {%- endif %}
+  {%- if unset_tags %}
+    {%- call statement('unset_tags') -%}
+       {{ alter_unset_tags(relation, unset_tags) }}
+    {%- endcall -%}
+  {%- endif %}
+{%- endmacro -%}
+
+{% macro alter_set_tags(relation, tags) -%}
+  ALTER {{ relation.type }} {{ relation }} SET TAGS (
+    {% for tag in tags -%}
+      '{{ tag }}' = '{{ tags[tag] }}' {%- if not loop.last %}, {% endif -%}
+    {%- endfor %}
+  )
+{%- endmacro -%}
+
+{% macro alter_unset_tags(relation, tags) -%}
+  ALTER {{ relation.type }} {{ relation }} UNSET TAGS (
+    {% for tag in tags -%}
+      '{{ tag }}' {%- if not loop.last %}, {%- endif %}
+    {%- endfor %}
+  )
+{%- endmacro -%}
diff --git a/dbt/include/databricks/macros/relations/tblproperties.sql b/dbt/include/databricks/macros/relations/tblproperties.sql
index 02ea1720d..446e7ba9e 100644
--- a/dbt/include/databricks/macros/relations/tblproperties.sql
+++ b/dbt/include/databricks/macros/relations/tblproperties.sql
@@ -11,4 +11,12 @@
       {%- endfor %}
     )
   {%- endif %}
+{%- endmacro -%}
+
+{% macro apply_tblproperties_python(relation, tblproperties, language) -%}
+  {%- if tblproperties and language == 'python' -%}
+    {%- call statement('python_tblproperties') -%}
+      alter table {{ relation }} set {{ tblproperties_clause() }}
+    {%- endcall -%}
+  {%- endif -%}
 {%- endmacro -%}
\ No newline at end of file
diff --git a/dbt/include/databricks/macros/relations/view/create.sql b/dbt/include/databricks/macros/relations/view/create.sql
index a18fc1778..096e12de4 100644
--- a/dbt/include/databricks/macros/relations/view/create.sql
+++ b/dbt/include/databricks/macros/relations/view/create.sql
@@ -17,4 +17,4 @@
   {{ tblproperties_clause() }}
   as
     {{ sql }}
-{% endmacro %}
\ No newline at end of file
+{% endmacro %}
diff --git a/dbt/include/databricks/macros/relations/view/drop.sql b/dbt/include/databricks/macros/relations/view/drop.sql
index 835d787e5..aa199d760 100644
--- a/dbt/include/databricks/macros/relations/view/drop.sql
+++ b/dbt/include/databricks/macros/relations/view/drop.sql
@@ -1,3 +1,3 @@
 {% macro databricks__drop_view(relation) -%}
     drop view if exists {{ relation }}
-{%- endmacro %}
\ No newline at end of file
+{%- endmacro %}
diff --git a/dev-requirements.txt b/dev-requirements.txt
index 2a320573a..b9d6bb8da 100644
--- a/dev-requirements.txt
+++ b/dev-requirements.txt
@@ -1,12 +1,3 @@
-# install latest changes in dbt-core
-# TODO: how to automate switching from develop to version branches?
-# git+https://github.com/dbt-labs/dbt-core.git#egg=dbt-core&subdirectory=core
-# git+https://github.com/dbt-labs/dbt-core.git#egg=dbt-tests-adapter&subdirectory=tests/adapter
-
-# install latest changes in dbt-spark
-# TODO: how to automate switching from develop to version branches?
-# git+https://github.com/dbt-labs/dbt-spark.git#egg=dbt-spark
-
 black==22.12.0
 flake8
 flaky
@@ -22,8 +13,6 @@ pytz
 tox>=3.2.0
 types-requests
 types-mock
+pre-commit
 
-git+https://github.com/dbt-labs/dbt-core.git#egg=dbt-core&subdirectory=core
-git+https://github.com/dbt-labs/dbt-common.git
-git+https://github.com/dbt-labs/dbt-adapters.git
-git+https://github.com/dbt-labs/dbt-adapters.git#subdirectory=dbt-tests-adapter
\ No newline at end of file
+dbt-tests-adapter~=1.8.0rc2
diff --git a/docs/local-dev.md b/docs/local-dev.md
index 24192fcb1..fe4a28200 100644
--- a/docs/local-dev.md
+++ b/docs/local-dev.md
@@ -13,7 +13,7 @@ This page describes how to develop a dbt project on your computer using `dbt-dat
 Before you scaffold a new dbt project, you have to collect some information which dbt will use to connect to Databricks. Where you find this information depends on whether you are using Databricks Clusters or Databricks SQL endpoints. We recommend that you develop dbt models against Databricks SQL endpoints as they provide the latest SQL features and optimizations.
 
 #### Databricks SQL endpoints
-1. Log in to your Databricks workspace 
+1. Log in to your Databricks workspace
 2. Click the _SQL_ persona in the left navigation bar to switch to Databricks SQL
 3. Click _SQL Endpoints_
 4. Choose the SQL endpoint you want to connect to
@@ -24,7 +24,7 @@ Before you scaffold a new dbt project, you have to collect some information whic
 ![image](/docs/img/sql-endpoint-connection-details.png "SQL endpoint connection details")
 
 #### Databricks Clusters
-1. Log in to your Databricks workspace 
+1. Log in to your Databricks workspace
 2. Click the _Data Science & Engineering_ persona in the left navigation bar
 3. Click _Compute_
 4. Click on the cluster you want to connect to
diff --git a/docs/oauth.md b/docs/oauth.md
index f56379573..9d95b652c 100644
--- a/docs/oauth.md
+++ b/docs/oauth.md
@@ -4,11 +4,11 @@ This feature is in [Public Preview](https://docs.databricks.com/release-notes/re
 
 Databricks DBT adapter now supports authentication via OAuth in AWS and Azure. This is a much safer method as it enables you to generate short-lived (one hour) OAuth access tokens, which eliminates the risk of accidentally exposing longer-lived tokens such as Databricks personal access tokens through version control checkins or other means. OAuth also enables better server-side session invalidation and scoping.
 
-Once an admin correctly configured OAuth in Databricks, you can simply add the config `auth_type` and set it to `oauth`. Config `token` is no longer necessary. 
+Once an admin correctly configured OAuth in Databricks, you can simply add the config `auth_type` and set it to `oauth`. Config `token` is no longer necessary.
 
 For Azure, you admin needs to create a Public AD application for dbt and provide you with its client_id.
 
-``` YAML
+```YAML
 jaffle_shop:
   outputs:
     dev:
@@ -22,5 +22,30 @@ jaffle_shop:
   target: dev
 ```
 
+## Troubleshooting
 
+DBT expects the OAuth application to have the "All APIs" scope and redirect URL `http://localhost:8020` by default.
 
+If the OAuth application has only been configured with SQL access scopes or a custom redirect URL, you may need to update your profile accordingly:
+
+```YAML
+jaffle_shop:
+  outputs:
+    dev:
+      host: <databricks host name>
+      http_path: <http path for warehouse or cluster>
+      catalog: <UC catalog name>
+      schema: <schema name>
+      auth_type: oauth  # new
+      client_id: <azure application ID> # only necessary for Azure
+      oauth_redirect_url: https://example.com
+      oauth_scopes:
+        - sql
+        - offline_access
+      type: databricks
+  target: dev
+```
+
+You can find these settings in [Account Console](https://accounts.cloud.databricks.com) > [Settings](https://accounts.cloud.databricks.com/settings) > [App Connections](https://accounts.cloud.databricks.com/settings/app-integrations) > dbt adapter for Databricks
+
+If you encounter any issues, please refer to the [OAuth user-to-machine (U2M) authentication guide](https://docs.databricks.com/en/dev-tools/auth/oauth-u2m.html).
diff --git a/requirements.txt b/requirements.txt
index 418022eaa..d62d4cd77 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -1,5 +1,7 @@
 databricks-sql-connector>=3.1.0, <3.2.0
-dbt-spark~=1.8.0b1
+dbt-spark~=1.8.0rc1
+dbt-core~=1.8.0rc2
+dbt-adapters~=1.1.1
 databricks-sdk==0.17.0
 keyring>=23.13.0
 pandas<2.2.0
diff --git a/setup.py b/setup.py
index 279893a6a..fe7f26d87 100644
--- a/setup.py
+++ b/setup.py
@@ -54,7 +54,9 @@ def _get_plugin_version() -> str:
     packages=find_namespace_packages(include=["dbt", "dbt.*"]),
     include_package_data=True,
     install_requires=[
-        "dbt-spark~=1.8.0b1",
+        "dbt-spark~=1.8.0rc1",
+        "dbt-core~=1.8.0rc2",
+        "dbt-adapters~=1.1.1",
         "databricks-sql-connector>=3.1.0, <3.2.0",
         "databricks-sdk==0.17.0",
         "keyring>=23.13.0",
diff --git a/tests/functional/adapter/aliases/test_aliases.py b/tests/functional/adapter/aliases/test_aliases.py
index 6ea72fb1e..af6682b90 100644
--- a/tests/functional/adapter/aliases/test_aliases.py
+++ b/tests/functional/adapter/aliases/test_aliases.py
@@ -1,12 +1,10 @@
-from dbt.tests.adapter.aliases.test_aliases import (
-    BaseAliases,
-    BaseAliasErrors,
-    BaseSameAliasDifferentSchemas,
-    BaseSameAliasDifferentDatabases,
-)
-from dbt.tests.adapter.aliases import fixtures as dbt_fixtures
 import pytest
 
+from dbt.tests.adapter.aliases import fixtures as dbt_fixtures
+from dbt.tests.adapter.aliases.test_aliases import BaseAliasErrors
+from dbt.tests.adapter.aliases.test_aliases import BaseAliases
+from dbt.tests.adapter.aliases.test_aliases import BaseSameAliasDifferentDatabases
+from dbt.tests.adapter.aliases.test_aliases import BaseSameAliasDifferentSchemas
 from tests.functional.adapter.aliases import fixtures as databricks_fixtures
 
 
@@ -59,7 +57,8 @@ def clean_up(self, project):
         yield
         with project.adapter.connection_named("__test"):
             relation = project.adapter.Relation.create(
-                database=project.database, schema=f"{project.test_schema}_{project.test_schema}_alt"
+                database=project.database,
+                schema=f"{project.test_schema}_{project.test_schema}_alt",
             )
             project.adapter.drop_schema(relation)
 
diff --git a/tests/functional/adapter/basic/test_docs_generate.py b/tests/functional/adapter/basic/test_docs_generate.py
index c40660d85..677879df4 100644
--- a/tests/functional/adapter/basic/test_docs_generate.py
+++ b/tests/functional/adapter/basic/test_docs_generate.py
@@ -1,10 +1,11 @@
-from dbt.tests.adapter.basic import expected_catalog
-from dbt.tests.adapter.basic.test_docs_generate import BaseDocsGenerate, BaseDocsGenReferences
-from dbt.tests.util import AnyString
-
 import pytest
 
-from tests.functional.adapter.basic.typing import AnyLongType, StatsLikeDict
+from dbt.tests.adapter.basic import expected_catalog
+from dbt.tests.adapter.basic.test_docs_generate import BaseDocsGenerate
+from dbt.tests.adapter.basic.test_docs_generate import BaseDocsGenReferences
+from dbt.tests.util import AnyString
+from tests.functional.adapter.basic.typing import AnyLongType
+from tests.functional.adapter.basic.typing import StatsLikeDict
 
 
 class TestDocsGenerate(BaseDocsGenerate):
diff --git a/tests/functional/adapter/basic/test_ensure_no_describe_extended.py b/tests/functional/adapter/basic/test_ensure_no_describe_extended.py
index 77298b91e..58d989c49 100644
--- a/tests/functional/adapter/basic/test_ensure_no_describe_extended.py
+++ b/tests/functional/adapter/basic/test_ensure_no_describe_extended.py
@@ -1,6 +1,6 @@
 import pytest
-from dbt.tests import util
 
+from dbt.tests import util
 from tests.functional.adapter.basic import fixtures
 
 
diff --git a/tests/functional/adapter/basic/test_incremental.py b/tests/functional/adapter/basic/test_incremental.py
index b6eb9a34e..4ed9d367f 100644
--- a/tests/functional/adapter/basic/test_incremental.py
+++ b/tests/functional/adapter/basic/test_incremental.py
@@ -1,7 +1,10 @@
 import os
-from dbt.tests.adapter.basic.test_incremental import BaseIncremental, BaseIncrementalNotSchemaChange
+
 import pytest
 
+from dbt.tests.adapter.basic.test_incremental import BaseIncremental
+from dbt.tests.adapter.basic.test_incremental import BaseIncrementalNotSchemaChange
+
 
 class TestIncrementalDelta(BaseIncremental):
     pass
diff --git a/tests/functional/adapter/basic/test_singular_tests_ephemeral.py b/tests/functional/adapter/basic/test_singular_tests_ephemeral.py
index 899195910..aa1b07583 100644
--- a/tests/functional/adapter/basic/test_singular_tests_ephemeral.py
+++ b/tests/functional/adapter/basic/test_singular_tests_ephemeral.py
@@ -1,4 +1,6 @@
-from dbt.tests.adapter.basic.test_singular_tests_ephemeral import BaseSingularTestsEphemeral
+from dbt.tests.adapter.basic.test_singular_tests_ephemeral import (
+    BaseSingularTestsEphemeral,
+)
 
 
 class TestSingularTestsEphemeral(BaseSingularTestsEphemeral):
diff --git a/tests/functional/adapter/caching/test_caching.py b/tests/functional/adapter/caching/test_caching.py
index c403574ca..206f092f1 100644
--- a/tests/functional/adapter/caching/test_caching.py
+++ b/tests/functional/adapter/caching/test_caching.py
@@ -1,9 +1,7 @@
-from dbt.tests.adapter.caching.test_caching import (
-    BaseNoPopulateCache,
-    BaseCachingLowercaseModel,
-    BaseCachingUppercaseModel,
-    BaseCachingSelectedSchemaOnly,
-)
+from dbt.tests.adapter.caching.test_caching import BaseCachingLowercaseModel
+from dbt.tests.adapter.caching.test_caching import BaseCachingSelectedSchemaOnly
+from dbt.tests.adapter.caching.test_caching import BaseCachingUppercaseModel
+from dbt.tests.adapter.caching.test_caching import BaseNoPopulateCache
 
 
 class TestNoPopulateCache(BaseNoPopulateCache):
diff --git a/tests/functional/adapter/concurrency/test_concurrency.py b/tests/functional/adapter/concurrency/test_concurrency.py
index b1b8aded5..a4e410940 100644
--- a/tests/functional/adapter/concurrency/test_concurrency.py
+++ b/tests/functional/adapter/concurrency/test_concurrency.py
@@ -1,5 +1,6 @@
 from dbt.tests import util
-from dbt.tests.adapter.concurrency.test_concurrency import BaseConcurrency, seeds__update_csv
+from dbt.tests.adapter.concurrency.test_concurrency import BaseConcurrency
+from dbt.tests.adapter.concurrency.test_concurrency import seeds__update_csv
 
 
 # Copied from dbt-core
diff --git a/tests/functional/adapter/constraints/test_constraints.py b/tests/functional/adapter/constraints/test_constraints.py
index ba8343960..5dd3db72e 100644
--- a/tests/functional/adapter/constraints/test_constraints.py
+++ b/tests/functional/adapter/constraints/test_constraints.py
@@ -1,17 +1,27 @@
 import pytest
+
+from dbt.tests import util
+from dbt.tests.adapter.constraints import fixtures
+from dbt.tests.adapter.constraints.test_constraints import BaseConstraintQuotedColumn
+from dbt.tests.adapter.constraints.test_constraints import BaseConstraintsRollback
 from dbt.tests.adapter.constraints.test_constraints import (
-    BaseTableConstraintsColumnsEqual,
-    BaseViewConstraintsColumnsEqual,
-    BaseIncrementalConstraintsColumnsEqual,
     BaseConstraintsRuntimeDdlEnforcement,
-    BaseConstraintsRollback,
-    BaseConstraintQuotedColumn,
-    BaseIncrementalConstraintsRuntimeDdlEnforcement,
+)
+from dbt.tests.adapter.constraints.test_constraints import (
+    BaseIncrementalConstraintsColumnsEqual,
+)
+from dbt.tests.adapter.constraints.test_constraints import (
     BaseIncrementalConstraintsRollback,
 )
-from dbt.tests.adapter.constraints import fixtures
-from dbt.tests import util
-
+from dbt.tests.adapter.constraints.test_constraints import (
+    BaseIncrementalConstraintsRuntimeDdlEnforcement,
+)
+from dbt.tests.adapter.constraints.test_constraints import (
+    BaseTableConstraintsColumnsEqual,
+)
+from dbt.tests.adapter.constraints.test_constraints import (
+    BaseViewConstraintsColumnsEqual,
+)
 from tests.functional.adapter.constraints import fixtures as override_fixtures
 
 
diff --git a/tests/functional/adapter/copy_into/test_copy_into.py b/tests/functional/adapter/copy_into/test_copy_into.py
index 81e84f9d4..834b1cf62 100644
--- a/tests/functional/adapter/copy_into/test_copy_into.py
+++ b/tests/functional/adapter/copy_into/test_copy_into.py
@@ -1,6 +1,6 @@
 import pytest
-from dbt.tests import util
 
+from dbt.tests import util
 from tests.functional.adapter.copy_into import fixtures
 
 
diff --git a/tests/functional/adapter/dbt_clone/test_dbt_clone.py b/tests/functional/adapter/dbt_clone/test_dbt_clone.py
index 368db3209..7c25baf70 100644
--- a/tests/functional/adapter/dbt_clone/test_dbt_clone.py
+++ b/tests/functional/adapter/dbt_clone/test_dbt_clone.py
@@ -1,8 +1,9 @@
-from dbt.tests.adapter.dbt_clone.test_dbt_clone import BaseClonePossible, BaseClone
-from dbt.tests import util
-
 import pytest
 
+from dbt.tests import util
+from dbt.tests.adapter.dbt_clone.test_dbt_clone import BaseClone
+from dbt.tests.adapter.dbt_clone.test_dbt_clone import BaseClonePossible
+
 
 class CleanupMixin:
     @pytest.fixture(autouse=True)
@@ -20,10 +21,12 @@ def clean_up(self, project):
             project.adapter.drop_schema(relation)
 
 
+@pytest.mark.skip("Skip until tests fixed upstream in 1.8.0 final")
 class TestClonePossible(BaseClonePossible, CleanupMixin):
     pass
 
 
+@pytest.mark.skip("Skip until tests fixed upstream in 1.8.0 final")
 class TestCloneSameTargetAndState(BaseClone, CleanupMixin):
     def test_clone_same_target_and_state(self, project, other_schema):
         project.create_test_schema(other_schema)
diff --git a/tests/functional/adapter/dbt_show/test_dbt_show.py b/tests/functional/adapter/dbt_show/test_dbt_show.py
index 98d603154..340828c02 100644
--- a/tests/functional/adapter/dbt_show/test_dbt_show.py
+++ b/tests/functional/adapter/dbt_show/test_dbt_show.py
@@ -1,4 +1,5 @@
-from dbt.tests.adapter.dbt_show.test_dbt_show import BaseShowLimit, BaseShowSqlHeader
+from dbt.tests.adapter.dbt_show.test_dbt_show import BaseShowLimit
+from dbt.tests.adapter.dbt_show.test_dbt_show import BaseShowSqlHeader
 
 
 class TestShowLimit(BaseShowLimit):
diff --git a/tests/functional/adapter/ephemeral/test_ephemeral.py b/tests/functional/adapter/ephemeral/test_ephemeral.py
index 2ff598450..81a320dbf 100644
--- a/tests/functional/adapter/ephemeral/test_ephemeral.py
+++ b/tests/functional/adapter/ephemeral/test_ephemeral.py
@@ -1,13 +1,13 @@
 import os
 import re
-from dbt.tests.adapter.ephemeral.test_ephemeral import (
-    BaseEphemeralMulti,
-    BaseEphemeral,
-)
-from dbt.tests.adapter.ephemeral import test_ephemeral
-from dbt.tests import util
+
 import pytest
 
+from dbt.tests import util
+from dbt.tests.adapter.ephemeral import test_ephemeral
+from dbt.tests.adapter.ephemeral.test_ephemeral import BaseEphemeral
+from dbt.tests.adapter.ephemeral.test_ephemeral import BaseEphemeralMulti
+
 
 class TestEphemeralMulti(BaseEphemeralMulti):
     def test_ephemeral_multi(self, project):
diff --git a/tests/functional/adapter/grants/test_grants.py b/tests/functional/adapter/grants/test_grants.py
index 4e3428b7d..0f9dfcdda 100644
--- a/tests/functional/adapter/grants/test_grants.py
+++ b/tests/functional/adapter/grants/test_grants.py
@@ -1,7 +1,8 @@
 import pytest
-from dbt.tests.adapter.grants.test_model_grants import BaseModelGrants
+
 from dbt.tests.adapter.grants.test_incremental_grants import BaseIncrementalGrants
 from dbt.tests.adapter.grants.test_invalid_grants import BaseInvalidGrants
+from dbt.tests.adapter.grants.test_model_grants import BaseModelGrants
 from dbt.tests.adapter.grants.test_seed_grants import BaseSeedGrants
 from dbt.tests.adapter.grants.test_snapshot_grants import BaseSnapshotGrants
 
diff --git a/tests/functional/adapter/hooks/test_model_hooks.py b/tests/functional/adapter/hooks/test_model_hooks.py
index ed22370e6..9a3ba61ed 100644
--- a/tests/functional/adapter/hooks/test_model_hooks.py
+++ b/tests/functional/adapter/hooks/test_model_hooks.py
@@ -1,9 +1,8 @@
-from dbt.tests.adapter.hooks.test_model_hooks import BaseTestPrePost
-from dbt.tests import util
-from dbt.tests.adapter.hooks import fixtures
-
 import pytest
 
+from dbt.tests import util
+from dbt.tests.adapter.hooks import fixtures
+from dbt.tests.adapter.hooks.test_model_hooks import BaseTestPrePost
 from tests.functional.adapter.hooks import fixtures as override_fixtures
 
 
@@ -11,7 +10,8 @@ class TestPrePostModelHooks(BaseTestPrePost):
     @pytest.fixture(scope="class", autouse=True)
     def setUp(self, project):
         util.run_sql_with_adapter(
-            project.adapter, f"drop table if exists { project.test_schema }.on_model_hook"
+            project.adapter,
+            f"drop table if exists { project.test_schema }.on_model_hook",
         )
         util.run_sql_with_adapter(project.adapter, override_fixtures.create_table_statement)
 
diff --git a/tests/functional/adapter/hooks/test_run_hooks.py b/tests/functional/adapter/hooks/test_run_hooks.py
index b07e3d581..91c228437 100644
--- a/tests/functional/adapter/hooks/test_run_hooks.py
+++ b/tests/functional/adapter/hooks/test_run_hooks.py
@@ -1,12 +1,11 @@
-from dbt.tests.adapter.hooks.test_run_hooks import (
-    BasePrePostRunHooks,
-    BaseAfterRunHooks,
-)
-import pytest
 import os
 
-from tests.functional.adapter.hooks import fixtures as override_fixtures
+import pytest
+
 from dbt.tests import util
+from dbt.tests.adapter.hooks.test_run_hooks import BaseAfterRunHooks
+from dbt.tests.adapter.hooks.test_run_hooks import BasePrePostRunHooks
+from tests.functional.adapter.hooks import fixtures as override_fixtures
 
 
 class TestPrePostRunHooks(BasePrePostRunHooks):
diff --git a/tests/functional/adapter/incremental/fixtures.py b/tests/functional/adapter/incremental/fixtures.py
index 96e4d2133..a0b9dc543 100644
--- a/tests/functional/adapter/incremental/fixtures.py
+++ b/tests/functional/adapter/incremental/fixtures.py
@@ -45,6 +45,36 @@
         - name: color
 """
 
+tags_a = """
+version: 2
+
+models:
+  - name: merge_update_columns_sql
+    config:
+        databricks_tags:
+            a: b
+            c: d
+    columns:
+        - name: id
+        - name: msg
+        - name: color
+"""
+
+tags_b = """
+version: 2
+
+models:
+  - name: merge_update_columns_sql
+    config:
+        databricks_tags:
+            c: e
+            d: f
+    columns:
+        - name: id
+        - name: msg
+        - name: color
+"""
+
 _MODELS__INCREMENTAL_SYNC_ALL_COLUMNS = """
 {{
     config(
@@ -223,3 +253,37 @@
 
 {% endif %}
 """
+
+
+simple_python_model = """
+import pandas
+
+def model(dbt, spark):
+    dbt.config(
+        materialized='incremental',
+    )
+    data = [[1,2]] * 10
+    return spark.createDataFrame(data, schema=['test', 'test2'])
+"""
+
+python_schema = """version: 2
+models:
+  - name: tags
+    config:
+      tags: ["python"]
+      databricks_tags:
+        a: b
+        c: d
+      http_path: "{{ env_var('DBT_DATABRICKS_UC_CLUSTER_HTTP_PATH') }}"
+"""
+
+python_schema2 = """version: 2
+models:
+  - name: tags
+    config:
+      tags: ["python"]
+      databricks_tags:
+        c: e
+        d: f
+      http_path: "{{ env_var('DBT_DATABRICKS_UC_CLUSTER_HTTP_PATH') }}"
+"""
diff --git a/tests/functional/adapter/incremental/test_incremental_on_schema_change.py b/tests/functional/adapter/incremental/test_incremental_on_schema_change.py
index 9536b1e5f..588d43a8c 100644
--- a/tests/functional/adapter/incremental/test_incremental_on_schema_change.py
+++ b/tests/functional/adapter/incremental/test_incremental_on_schema_change.py
@@ -1,8 +1,9 @@
+import pytest
+
+from dbt.tests.adapter.incremental import fixtures
 from dbt.tests.adapter.incremental.test_incremental_on_schema_change import (
     BaseIncrementalOnSchemaChange,
 )
-import pytest
-from dbt.tests.adapter.incremental import fixtures
 from tests.functional.adapter.incremental import fixtures as fixture_overrides
 
 
diff --git a/tests/functional/adapter/incremental/test_incremental_persist_docs.py b/tests/functional/adapter/incremental/test_incremental_persist_docs.py
index 466938d33..b4240c2bb 100644
--- a/tests/functional/adapter/incremental/test_incremental_persist_docs.py
+++ b/tests/functional/adapter/incremental/test_incremental_persist_docs.py
@@ -1,8 +1,8 @@
+import pytest
+
 from dbt.tests import util
 from tests.functional.adapter.incremental import fixtures
 
-import pytest
-
 
 class TestIncrementalPersistDocs:
     @pytest.fixture(scope="class")
diff --git a/tests/functional/adapter/incremental/test_incremental_predicates.py b/tests/functional/adapter/incremental/test_incremental_predicates.py
index 369c79fab..d63d8a9fe 100644
--- a/tests/functional/adapter/incremental/test_incremental_predicates.py
+++ b/tests/functional/adapter/incremental/test_incremental_predicates.py
@@ -1,5 +1,8 @@
 import pytest
-from dbt.tests.adapter.incremental.test_incremental_predicates import BaseIncrementalPredicates
+
+from dbt.tests.adapter.incremental.test_incremental_predicates import (
+    BaseIncrementalPredicates,
+)
 from tests.functional.adapter.incremental import fixtures
 
 
diff --git a/tests/functional/adapter/incremental/test_incremental_strategies.py b/tests/functional/adapter/incremental/test_incremental_strategies.py
index 079537b72..1c0162dfd 100644
--- a/tests/functional/adapter/incremental/test_incremental_strategies.py
+++ b/tests/functional/adapter/incremental/test_incremental_strategies.py
@@ -1,5 +1,7 @@
 import os
+
 import pytest
+
 from dbt.tests import util
 from tests.functional.adapter.incremental import fixtures
 
@@ -95,7 +97,12 @@ class TestInsertOverwriteDelta(InsertOverwriteBase):
 class TestInsertOverwriteWithPartitionsDelta(InsertOverwriteBase):
     @pytest.fixture(scope="class")
     def project_config_update(self):
-        return {"models": {"+incremental_strategy": "insert_overwrite", "+partition_by": "id"}}
+        return {
+            "models": {
+                "+incremental_strategy": "insert_overwrite",
+                "+partition_by": "id",
+            }
+        }
 
 
 @pytest.mark.skip_profile("databricks_uc_cluster", "databricks_cluster")
diff --git a/tests/functional/adapter/incremental/test_incremental_tags.py b/tests/functional/adapter/incremental/test_incremental_tags.py
new file mode 100644
index 000000000..4f9b9e7e2
--- /dev/null
+++ b/tests/functional/adapter/incremental/test_incremental_tags.py
@@ -0,0 +1,53 @@
+import pytest
+from dbt.tests import util
+from tests.functional.adapter.incremental import fixtures
+
+
+@pytest.mark.skip_profile("databricks_cluster")
+class TestIncrementalTags:
+    @pytest.fixture(scope="class")
+    def models(self):
+        return {
+            "merge_update_columns_sql.sql": fixtures.merge_update_columns_sql,
+            "schema.yml": fixtures.tags_a,
+        }
+
+    def test_changing_tags(self, project):
+        util.run_dbt(["run"])
+        util.write_file(fixtures.tags_b, "models", "schema.yml")
+        util.run_dbt(["run"])
+        results = project.run_sql(
+            "select tag_name, tag_value from {database}.information_schema.table_tags "
+            "where schema_name = '{schema}' and table_name='merge_update_columns_sql'",
+            fetch="all",
+        )
+        assert len(results) == 2
+        results_dict = {}
+        results_dict[results[0].tag_name] = results[0].tag_value
+        results_dict[results[1].tag_name] = results[1].tag_value
+        assert results_dict == {"c": "e", "d": "f"}
+
+
+@pytest.mark.skip_profile("databricks_cluster")
+class TestIncrementalPythonTags:
+    @pytest.fixture(scope="class")
+    def models(self):
+        return {
+            "tags.py": fixtures.simple_python_model,
+            "schema.yml": fixtures.python_schema,
+        }
+
+    def test_changing_tags(self, project):
+        util.run_dbt(["run"])
+        util.write_file(fixtures.python_schema2, "models", "schema.yml")
+        util.run_dbt(["run"])
+        results = project.run_sql(
+            "select tag_name, tag_value from {database}.information_schema.table_tags "
+            "where schema_name = '{schema}' and table_name='tags'",
+            fetch="all",
+        )
+        assert len(results) == 2
+        results_dict = {}
+        results_dict[results[0].tag_name] = results[0].tag_value
+        results_dict[results[1].tag_name] = results[1].tag_value
+        assert results_dict == {"c": "e", "d": "f"}
diff --git a/tests/functional/adapter/incremental/test_incremental_unique_id.py b/tests/functional/adapter/incremental/test_incremental_unique_id.py
index 167b76dcd..311710df7 100644
--- a/tests/functional/adapter/incremental/test_incremental_unique_id.py
+++ b/tests/functional/adapter/incremental/test_incremental_unique_id.py
@@ -1,4 +1,6 @@
-from dbt.tests.adapter.incremental.test_incremental_unique_id import BaseIncrementalUniqueKey
+from dbt.tests.adapter.incremental.test_incremental_unique_id import (
+    BaseIncrementalUniqueKey,
+)
 
 
 class TestUniqueKeyDatabricks(BaseIncrementalUniqueKey):
diff --git a/tests/functional/adapter/liquid_clustering/test_liquid_clustering.py b/tests/functional/adapter/liquid_clustering/test_liquid_clustering.py
index fa7b45dbd..a9cc0ee09 100644
--- a/tests/functional/adapter/liquid_clustering/test_liquid_clustering.py
+++ b/tests/functional/adapter/liquid_clustering/test_liquid_clustering.py
@@ -1,4 +1,5 @@
 import pytest
+
 from dbt.tests import util
 from tests.functional.adapter.liquid_clustering import fixtures
 
diff --git a/tests/functional/adapter/long_sessions/test_long_sessions.py b/tests/functional/adapter/long_sessions/test_long_sessions.py
index 5118f2367..2f7e8065d 100644
--- a/tests/functional/adapter/long_sessions/test_long_sessions.py
+++ b/tests/functional/adapter/long_sessions/test_long_sessions.py
@@ -1,6 +1,7 @@
-import pytest
 import os
 from unittest import mock
+
+import pytest
 from dbt.tests import util
 from tests.functional.adapter.long_sessions import fixtures
 
@@ -96,5 +97,5 @@ def test_long_sessions(self, project):
         util.run_dbt(["--debug", "seed", "--target", "idle_sessions"])
 
         _, log = util.run_dbt_and_capture(["--debug", "run", "--target", "idle_sessions"])
-        idle_count = log.count("closing idle connection") / 2
+        idle_count = log.count("Closing for idleness") / 2
         assert idle_count > 0
diff --git a/tests/functional/adapter/materialized_view_tests/fixtures.py b/tests/functional/adapter/materialized_view_tests/fixtures.py
index 4b0dd15bf..1a0c74516 100644
--- a/tests/functional/adapter/materialized_view_tests/fixtures.py
+++ b/tests/functional/adapter/materialized_view_tests/fixtures.py
@@ -1,6 +1,6 @@
 from typing import Optional
-from dbt.adapters.base import BaseRelation
 
+from dbt.adapters.base import BaseRelation
 from dbt.adapters.databricks.relation import DatabricksRelationType
 
 
diff --git a/tests/functional/adapter/materialized_view_tests/test_basic.py b/tests/functional/adapter/materialized_view_tests/test_basic.py
index 0102e0b37..22b74ac09 100644
--- a/tests/functional/adapter/materialized_view_tests/test_basic.py
+++ b/tests/functional/adapter/materialized_view_tests/test_basic.py
@@ -1,9 +1,11 @@
-from typing import Optional, Tuple
-from dbt.tests.adapter.materialized_view.basic import MaterializedViewBasic
-from dbt.adapters.base.relation import BaseRelation
-from dbt.tests import util
+from typing import Optional
+from typing import Tuple
+
 import pytest
 
+from dbt.adapters.base.relation import BaseRelation
+from dbt.tests import util
+from dbt.tests.adapter.materialized_view.basic import MaterializedViewBasic
 from tests.functional.adapter.materialized_view_tests import fixtures
 
 
diff --git a/tests/functional/adapter/materialized_view_tests/test_changes.py b/tests/functional/adapter/materialized_view_tests/test_changes.py
index 4243b4273..a113d2fb7 100644
--- a/tests/functional/adapter/materialized_view_tests/test_changes.py
+++ b/tests/functional/adapter/materialized_view_tests/test_changes.py
@@ -1,16 +1,21 @@
 from typing import Optional
+
+import pytest
+
+from dbt.adapters.base import BaseRelation
+from dbt.adapters.databricks.relation_configs.materialized_view import (
+    MaterializedViewConfig,
+)
+from dbt.adapters.databricks.relation_configs.tblproperties import TblPropertiesConfig
+from dbt.tests import util
+from dbt.tests.adapter.materialized_view.changes import MaterializedViewChanges
 from dbt.tests.adapter.materialized_view.changes import (
-    MaterializedViewChanges,
     MaterializedViewChangesApplyMixin,
+)
+from dbt.tests.adapter.materialized_view.changes import (
     MaterializedViewChangesContinueMixin,
-    MaterializedViewChangesFailMixin,
 )
-from dbt.adapters.base import BaseRelation
-from dbt.tests import util
-import pytest
-from dbt.adapters.databricks.relation_configs.materialized_view import MaterializedViewConfig
-from dbt.adapters.databricks.relation_configs.tblproperties import TblPropertiesConfig
-
+from dbt.tests.adapter.materialized_view.changes import MaterializedViewChangesFailMixin
 from tests.functional.adapter.materialized_view_tests import fixtures
 
 
diff --git a/tests/functional/adapter/persist_constraints/test_persist_constraints.py b/tests/functional/adapter/persist_constraints/test_persist_constraints.py
index fa893d799..324cb1fa6 100644
--- a/tests/functional/adapter/persist_constraints/test_persist_constraints.py
+++ b/tests/functional/adapter/persist_constraints/test_persist_constraints.py
@@ -1,8 +1,11 @@
 from typing import Dict
-from dbt.contracts.results import RunResult, RunStatus
+
 import pytest
-from tests.functional.adapter.persist_constraints import fixtures
+
+from dbt.contracts.results import RunResult
+from dbt.contracts.results import RunStatus
 from dbt.tests import util
+from tests.functional.adapter.persist_constraints import fixtures
 
 
 class TestConstraints:
diff --git a/tests/functional/adapter/persist_docs/test_persist_docs.py b/tests/functional/adapter/persist_docs/test_persist_docs.py
index 6a38863ed..60fa374ae 100644
--- a/tests/functional/adapter/persist_docs/test_persist_docs.py
+++ b/tests/functional/adapter/persist_docs/test_persist_docs.py
@@ -1,64 +1,244 @@
-from dbt.tests.adapter.persist_docs.test_persist_docs import (
-    BasePersistDocs,
-    BasePersistDocsColumnMissing,
-    BasePersistDocsCommentOnQuotedColumn,
-)
+import os
+
 import pytest
+from agate import Table
+from dbt.adapters.databricks.impl import DatabricksAdapter
+from dbt.adapters.databricks.relation import DatabricksRelation
+from dbt.tests import util
+from dbt.tests.adapter.persist_docs import fixtures
+
+
+class DatabricksPersistDocsMixin:
+    @pytest.fixture(scope="class", autouse=True)
+    def setUp(self, project):
+        util.run_dbt(["seed"])
+        util.run_dbt()
+
+    @pytest.fixture(scope="class")
+    def seeds(self):
+        return {"seed.csv": fixtures._SEEDS__SEED}
 
+    @pytest.fixture(scope="class")
+    def models(self):
+        return {
+            "no_docs_model.sql": fixtures._MODELS__NO_DOCS_MODEL,
+            "table_model.sql": fixtures._MODELS__TABLE,
+            "view_model.sql": fixtures._MODELS__VIEW,
+        }
+
+    @pytest.fixture(scope="class")
+    def properties(self):
+        return {
+            "my_fun_docs.md": fixtures._DOCS__MY_FUN_DOCS,
+            "schema.yml": fixtures._PROPERTIES__SCHEMA_YML,
+        }
+
+    def _assert_common_comments(self, *comments):
+        for comment in comments:
+            assert '"with double quotes"' in comment
+            assert """'''abc123'''""" in comment
+            assert "\n" in comment
+            assert "Some $lbl$ labeled $lbl$ and $$ unlabeled $$ dollar-quoting" in comment
+            assert "/* comment */" in comment
+            if os.name == "nt":
+                assert "--\r\n" in comment or "--\n" in comment
+            else:
+                assert "--\n" in comment
 
-class DatabricksPersistMixin:
     def _assert_has_view_comments(
-        self, view_node, has_node_comments=True, has_column_comments=True
+        self,
+        adapter: DatabricksAdapter,
+        relation: DatabricksRelation,
+        has_node_comments: bool = True,
+        has_column_comments: bool = True,
     ):
-        view_comment = view_node["metadata"]["comment"]
+        results = util.run_sql_with_adapter(adapter, f"describe extended {relation}", fetch="all")
+        metadata, columns = adapter.parse_describe_extended(
+            relation, Table(results, ["col_name", "data_type", "comment"])
+        )
+        view_comment = metadata["Comment"]
+
         if has_node_comments:
             assert view_comment.startswith("View model description")
             self._assert_common_comments(view_comment)
         else:
             assert view_comment == "" or view_comment is None
 
-        view_id_comment = view_node["columns"]["id"]["comment"]
-        if has_column_comments:
-            assert view_id_comment.startswith("id Column description")
-            self._assert_common_comments(view_id_comment)
-        else:
-            assert view_id_comment is None
+        for column in columns:
+            if column.column == "id":
+                view_id_comment = column.comment
+                if has_column_comments:
+                    assert view_id_comment and view_id_comment.startswith("id Column description")
+                    self._assert_common_comments(view_id_comment)
+                else:
+                    assert view_id_comment is None
 
-        view_name_comment = view_node["columns"]["name"]["comment"]
-        assert view_name_comment is None
+            if column.column == "name":
+                view_name_comment = column.comment
+                assert view_name_comment is None
 
+    def _assert_has_table_comments(self, adapter: DatabricksAdapter, relation: DatabricksRelation):
+        results = util.run_sql_with_adapter(adapter, f"describe extended {relation}", fetch="all")
+        metadata, columns = adapter.parse_describe_extended(
+            relation, Table(results, ["col_name", "data_type", "comment"])
+        )
+        table_comment = metadata["Comment"]
+        assert table_comment.startswith("Table model description")
 
-@pytest.mark.skip_profile("databricks_cluster")
-class TestPersistDocsUC(DatabricksPersistMixin, BasePersistDocs):
-    pass
+        for column in columns:
+            if column.column == "id":
+                table_id_comment = column.comment
+                assert table_id_comment and table_id_comment.startswith("id Column description")
+                self._assert_common_comments(table_id_comment)
 
+            if column.column == "name":
+                table_name_comment = column.comment
+                assert table_name_comment and table_name_comment.startswith(
+                    "Some stuff here and then a call to"
+                )
 
-@pytest.mark.skip_profile("databricks_uc_cluster", "databricks_uc_sql_endpoint")
-class TestPersistDocsHMS(BasePersistDocs):
-    def _assert_has_table_comments(self, table_node):
-        table_comment = table_node["metadata"]["comment"]
-        assert table_comment.startswith("Table model description")
+        self._assert_common_comments(table_comment, table_id_comment, table_name_comment)
 
-        self._assert_common_comments(table_comment)
 
-    def _assert_has_view_comments(
-        self, view_node, has_node_comments=True, has_column_comments=True
-    ):
-        view_comment = view_node["metadata"]["comment"]
-        if has_node_comments:
-            assert view_comment.startswith("View model description")
-            self._assert_common_comments(view_comment)
-        else:
-            assert view_comment is None
+class TestPersistDocs(DatabricksPersistDocsMixin):
+    @pytest.fixture(scope="class")
+    def view_relation(self, project):
+        return DatabricksRelation.create(
+            database=project.database,
+            schema=project.test_schema,
+            identifier="view_model",
+            type="view",
+        )
+
+    @pytest.fixture(scope="class")
+    def table_relation(self, project):
+        return DatabricksRelation.create(
+            database=project.database,
+            schema=project.test_schema,
+            identifier="table_model",
+            type="table",
+        )
+
+    @pytest.fixture(scope="class")
+    def no_docs_relation(self, project):
+        return DatabricksRelation.create(
+            database=project.database,
+            schema=project.test_schema,
+            identifier="no_docs_model",
+            type="view",
+        )
+
+    @pytest.fixture(scope="class")
+    def project_config_update(self):
+        return {
+            "models": {
+                "test": {
+                    "+persist_docs": {
+                        "relation": True,
+                        "columns": True,
+                    },
+                }
+            }
+        }
+
+    def test_has_comments(self, adapter, view_relation, table_relation, no_docs_relation):
+        self._assert_has_view_comments(adapter, view_relation)
+        self._assert_has_table_comments(adapter, table_relation)
+        self._assert_has_view_comments(adapter, no_docs_relation, False, False)
+
+
+class TestPersistDocsColumnMissing(DatabricksPersistDocsMixin):
+    @pytest.fixture(scope="class")
+    def project_config_update(self):
+        return {
+            "models": {
+                "test": {
+                    "+persist_docs": {
+                        "columns": True,
+                    },
+                }
+            }
+        }
+
+    @pytest.fixture(scope="class")
+    def models(self):
+        return {"missing_column.sql": fixtures._MODELS__MISSING_COLUMN}
+
+    @pytest.fixture(scope="class")
+    def properties(self):
+        return {"schema.yml": fixtures._PROPERITES__SCHEMA_MISSING_COL}
+
+    @pytest.fixture(scope="class")
+    def table_relation(self, project):
+        return DatabricksRelation.create(
+            database=project.database,
+            schema=project.test_schema,
+            identifier="missing_column",
+            type="table",
+        )
+
+    def test_missing_column(self, adapter, table_relation):
+        results = util.run_sql_with_adapter(
+            adapter, f"describe extended {table_relation}", fetch="all"
+        )
+        _, columns = adapter.parse_describe_extended(
+            table_relation, Table(results, ["col_name", "data_type", "comment"])
+        )
+        for column in columns:
+            if column.column == "id":
+                table_id_comment = column.comment
+                assert table_id_comment and table_id_comment.startswith(
+                    "test id column description"
+                )
+                break
+
+
+class TestPersistDocsCommentOnQuotedColumn:
+    @pytest.fixture(scope="class", autouse=True)
+    def setUp(self, project):
+        util.run_dbt()
+
+    @pytest.fixture(scope="class")
+    def models(self):
+        return {"quote_model.sql": fixtures._MODELS__MODEL_USING_QUOTE_UTIL}
+
+    @pytest.fixture(scope="class")
+    def properties(self):
+        return {"properties.yml": fixtures._PROPERTIES__QUOTE_MODEL}
 
+    @pytest.fixture(scope="class")
+    def project_config_update(self):
+        return {
+            "models": {
+                "test": {
+                    "materialized": "table",
+                    "+persist_docs": {
+                        "relation": True,
+                        "columns": True,
+                    },
+                }
+            }
+        }
 
-@pytest.mark.skip_profile("databricks_cluster")
-class TestPersistDocsUCColumnMissing(DatabricksPersistMixin, BasePersistDocsColumnMissing):
-    pass
+    @pytest.fixture(scope="class")
+    def table_relation(self, project):
+        return DatabricksRelation.create(
+            database=project.database,
+            schema=project.test_schema,
+            identifier="quote_model",
+            type="table",
+        )
 
+    def test_quoted_column_comments(self, adapter, table_relation):
+        results = util.run_sql_with_adapter(
+            adapter, f"describe extended {table_relation}", fetch="all"
+        )
+        _, columns = adapter.parse_describe_extended(
+            table_relation, Table(results, ["col_name", "data_type", "comment"])
+        )
 
-@pytest.mark.skip_profile("databricks_cluster")
-class TestPersistDocsUCCommentOnQuotedColumn(
-    DatabricksPersistMixin, BasePersistDocsCommentOnQuotedColumn
-):
-    pass
+        for column in columns:
+            if column.column == "2id":
+                column_comment = column.comment
+                assert column_comment.startswith("XXX")
+                break
diff --git a/tests/functional/adapter/python_model/fixtures.py b/tests/functional/adapter/python_model/fixtures.py
index d5d3f61ff..19a09112d 100644
--- a/tests/functional/adapter/python_model/fixtures.py
+++ b/tests/functional/adapter/python_model/fixtures.py
@@ -93,6 +93,7 @@ def model(dbt, spark):
     dbt.config(materialized="incremental")
     dbt.config(partition_by="date")
     dbt.config(unique_key="name")
+    dbt.config(tblproperties={"a": "b", "c": "d"})
     if dbt.is_incremental:
         data = [[2, "Teo"], [2, "Fang"], [3, "Elbert"]]
     else:
diff --git a/tests/functional/adapter/python_model/test_python_model.py b/tests/functional/adapter/python_model/test_python_model.py
index b68ca6ba4..8e89239ce 100644
--- a/tests/functional/adapter/python_model/test_python_model.py
+++ b/tests/functional/adapter/python_model/test_python_model.py
@@ -1,13 +1,10 @@
 import os
 
 import pytest
-
 from dbt.tests import util
-from dbt.tests.adapter.python_model.test_python_model import (
-    BasePythonIncrementalTests,
-    BasePythonModelTests,
-)
 from dbt.tests.adapter.python_model import test_python_model as fixtures
+from dbt.tests.adapter.python_model.test_python_model import BasePythonIncrementalTests
+from dbt.tests.adapter.python_model.test_python_model import BasePythonModelTests
 from tests.functional.adapter.python_model import fixtures as override_fixtures
 
 
@@ -93,3 +90,9 @@ def test_expected_handling_of_complex_config(self, project):
         util.run_dbt(["build", "-s", "complex_config"])
         util.run_dbt(["build", "-s", "complex_config"])
         util.check_relations_equal(project.adapter, ["complex_config", "expected_complex"])
+        results = project.run_sql(
+            "SHOW TBLPROPERTIES {database}.{schema}.complex_config", fetch="all"
+        )
+        result_dict = {result[0]: result[1] for result in results}
+        assert result_dict["a"] == "b"
+        assert result_dict["c"] == "d"
diff --git a/tests/functional/adapter/python_model/test_spark.py b/tests/functional/adapter/python_model/test_spark.py
index f42cc2676..222fb60a3 100644
--- a/tests/functional/adapter/python_model/test_spark.py
+++ b/tests/functional/adapter/python_model/test_spark.py
@@ -1,10 +1,10 @@
 import pytest
 
+from dbt.tests import util
+from dbt.tests.adapter.python_model import test_spark as fixtures
 from dbt.tests.adapter.python_model.test_spark import (
     BasePySparkTests,
 )
-from dbt.tests.adapter.python_model import test_spark as fixtures
-from dbt.tests import util
 
 
 @pytest.mark.skip_profile("databricks_uc_sql_endpoint")
diff --git a/tests/functional/adapter/query_comments/test_query_comment.py b/tests/functional/adapter/query_comments/test_query_comment.py
index 7bd674ef7..e058668f5 100644
--- a/tests/functional/adapter/query_comments/test_query_comment.py
+++ b/tests/functional/adapter/query_comments/test_query_comment.py
@@ -1,12 +1,15 @@
+import pytest
+
+from dbt.tests.adapter.query_comment.test_query_comment import BaseEmptyQueryComments
 from dbt.tests.adapter.query_comment.test_query_comment import (
-    BaseQueryComments,
-    BaseMacroQueryComments,
     BaseMacroArgsQueryComments,
+)
+from dbt.tests.adapter.query_comment.test_query_comment import (
     BaseMacroInvalidQueryComments,
-    BaseNullQueryComments,
-    BaseEmptyQueryComments,
 )
-import pytest
+from dbt.tests.adapter.query_comment.test_query_comment import BaseMacroQueryComments
+from dbt.tests.adapter.query_comment.test_query_comment import BaseNullQueryComments
+from dbt.tests.adapter.query_comment.test_query_comment import BaseQueryComments
 
 
 class TestQueryComments(BaseQueryComments):
diff --git a/tests/functional/adapter/simple_copy/test_simple_copy.py b/tests/functional/adapter/simple_copy/test_simple_copy.py
index 71a35f823..a7328d991 100644
--- a/tests/functional/adapter/simple_copy/test_simple_copy.py
+++ b/tests/functional/adapter/simple_copy/test_simple_copy.py
@@ -1,9 +1,8 @@
-from dbt.tests.adapter.simple_copy.test_simple_copy import (
-    SimpleCopyBase,
-    EmptyModelsArentRunBase,
-)
 import pytest
 
+from dbt.tests.adapter.simple_copy.test_simple_copy import EmptyModelsArentRunBase
+from dbt.tests.adapter.simple_copy.test_simple_copy import SimpleCopyBase
+
 
 # Tests with materialized_views, which only works for SQL Warehouse
 @pytest.mark.skip_profile("databricks_cluster", "databricks_uc_cluster")
diff --git a/tests/functional/adapter/simple_seed/test_seeds.py b/tests/functional/adapter/simple_seed/test_seeds.py
index 956000adc..b46d365d9 100644
--- a/tests/functional/adapter/simple_seed/test_seeds.py
+++ b/tests/functional/adapter/simple_seed/test_seeds.py
@@ -1,21 +1,20 @@
 from pathlib import Path
-from dbt.tests.adapter.simple_seed.test_seed import (
-    BaseSeedWithUniqueDelimiter,
-    BaseSeedWithWrongDelimiter,
-    BaseSeedWithEmptyDelimiter,
-    BaseTestEmptySeed,
-    BaseSeedConfigFullRefreshOff,
-    BaseSeedCustomSchema,
-    SeedTestBase,
-    BaseSimpleSeedEnabledViaConfig,
-    BaseSeedParsing,
-    BaseSimpleSeedWithBOM,
-    BaseSeedSpecificFormats,
-)
-from dbt.tests.adapter.simple_seed import seeds
-from dbt.tests import util
+
 import pytest
 
+from dbt.tests import util
+from dbt.tests.adapter.simple_seed import seeds
+from dbt.tests.adapter.simple_seed.test_seed import BaseSeedConfigFullRefreshOff
+from dbt.tests.adapter.simple_seed.test_seed import BaseSeedCustomSchema
+from dbt.tests.adapter.simple_seed.test_seed import BaseSeedParsing
+from dbt.tests.adapter.simple_seed.test_seed import BaseSeedSpecificFormats
+from dbt.tests.adapter.simple_seed.test_seed import BaseSeedWithEmptyDelimiter
+from dbt.tests.adapter.simple_seed.test_seed import BaseSeedWithUniqueDelimiter
+from dbt.tests.adapter.simple_seed.test_seed import BaseSeedWithWrongDelimiter
+from dbt.tests.adapter.simple_seed.test_seed import BaseSimpleSeedEnabledViaConfig
+from dbt.tests.adapter.simple_seed.test_seed import BaseSimpleSeedWithBOM
+from dbt.tests.adapter.simple_seed.test_seed import BaseTestEmptySeed
+from dbt.tests.adapter.simple_seed.test_seed import SeedTestBase
 from tests.functional.adapter.simple_seed import fixtures
 
 
diff --git a/tests/functional/adapter/simple_snapshot/test_snapshot.py b/tests/functional/adapter/simple_snapshot/test_snapshot.py
index 1ee96cb31..0d1b4d4e2 100644
--- a/tests/functional/adapter/simple_snapshot/test_snapshot.py
+++ b/tests/functional/adapter/simple_snapshot/test_snapshot.py
@@ -1,9 +1,8 @@
 from typing import Optional
-from dbt.tests.adapter.simple_snapshot.test_snapshot import (
-    BaseSimpleSnapshot,
-    BaseSnapshotCheck,
-)
+
 from dbt.tests import util
+from dbt.tests.adapter.simple_snapshot.test_snapshot import BaseSimpleSnapshot
+from dbt.tests.adapter.simple_snapshot.test_snapshot import BaseSnapshotCheck
 
 
 class TestSnapshot(BaseSimpleSnapshot):
diff --git a/tests/functional/adapter/store_test_failures/test_store_failures_as.py b/tests/functional/adapter/store_test_failures/test_store_failures_as.py
index 02a506b8d..ebdb4b2f1 100644
--- a/tests/functional/adapter/store_test_failures/test_store_failures_as.py
+++ b/tests/functional/adapter/store_test_failures/test_store_failures_as.py
@@ -1,10 +1,18 @@
+from dbt.tests.adapter.store_test_failures_tests.basic import (
+    StoreTestFailuresAsExceptions,
+)
+from dbt.tests.adapter.store_test_failures_tests.basic import StoreTestFailuresAsGeneric
 from dbt.tests.adapter.store_test_failures_tests.basic import (
     StoreTestFailuresAsInteractions,
+)
+from dbt.tests.adapter.store_test_failures_tests.basic import (
+    StoreTestFailuresAsProjectLevelEphemeral,
+)
+from dbt.tests.adapter.store_test_failures_tests.basic import (
     StoreTestFailuresAsProjectLevelOff,
+)
+from dbt.tests.adapter.store_test_failures_tests.basic import (
     StoreTestFailuresAsProjectLevelView,
-    StoreTestFailuresAsProjectLevelEphemeral,
-    StoreTestFailuresAsGeneric,
-    StoreTestFailuresAsExceptions,
 )
 from dbt.tests.adapter.store_test_failures_tests.test_store_test_failures import (
     BaseStoreTestFailures,
diff --git a/tests/functional/adapter/streaming_tables/fixtures.py b/tests/functional/adapter/streaming_tables/fixtures.py
index adbae2b51..724e72899 100644
--- a/tests/functional/adapter/streaming_tables/fixtures.py
+++ b/tests/functional/adapter/streaming_tables/fixtures.py
@@ -1,6 +1,6 @@
 from typing import Optional
-from dbt.adapters.base.relation import BaseRelation
 
+from dbt.adapters.base.relation import BaseRelation
 from dbt.adapters.databricks.relation import DatabricksRelationType
 
 
diff --git a/tests/functional/adapter/streaming_tables/test_st_basic.py b/tests/functional/adapter/streaming_tables/test_st_basic.py
index 7e03af36f..cf26ba854 100644
--- a/tests/functional/adapter/streaming_tables/test_st_basic.py
+++ b/tests/functional/adapter/streaming_tables/test_st_basic.py
@@ -1,14 +1,14 @@
-from typing import Optional, Tuple
-from dbt.adapters.base.relation import BaseRelation
-from dbt.tests.adapter.materialized_view.files import (
-    MY_SEED,
-    MY_TABLE,
-    MY_VIEW,
-)
-from dbt.tests import util
+from typing import Optional
+from typing import Tuple
 
 import pytest
+
+from dbt.adapters.base.relation import BaseRelation
 from dbt.adapters.databricks.relation import DatabricksRelationType
+from dbt.tests import util
+from dbt.tests.adapter.materialized_view.files import MY_SEED
+from dbt.tests.adapter.materialized_view.files import MY_TABLE
+from dbt.tests.adapter.materialized_view.files import MY_VIEW
 from tests.functional.adapter.streaming_tables import fixtures
 
 
@@ -136,7 +136,13 @@ def test_streaming_table_create_idempotent(self, project, my_streaming_table):
 
     def test_streaming_table_full_refresh(self, project, my_streaming_table):
         _, logs = util.run_dbt_and_capture(
-            ["--debug", "run", "--models", my_streaming_table.identifier, "--full-refresh"]
+            [
+                "--debug",
+                "run",
+                "--models",
+                my_streaming_table.identifier,
+                "--full-refresh",
+            ]
         )
         assert self.query_relation_type(project, my_streaming_table) == "streaming_table"
         util.assert_message_in_logs(f"Applying REPLACE to: {my_streaming_table}", logs)
diff --git a/tests/functional/adapter/streaming_tables/test_st_changes.py b/tests/functional/adapter/streaming_tables/test_st_changes.py
index 365885371..ef8497d60 100644
--- a/tests/functional/adapter/streaming_tables/test_st_changes.py
+++ b/tests/functional/adapter/streaming_tables/test_st_changes.py
@@ -1,15 +1,18 @@
 from typing import Optional
-from dbt.adapters.base.relation import BaseRelation
-from dbt.tests.adapter.materialized_view.files import (
-    MY_SEED,
-)
-from dbt_common.contracts.config.materialization import OnConfigurationChangeOption
-from dbt.tests import util
 
 import pytest
+from dbt_common.contracts.config.materialization import OnConfigurationChangeOption
+
+from dbt.adapters.base.relation import BaseRelation
 from dbt.adapters.databricks.relation import DatabricksRelationType
-from dbt.adapters.databricks.relation_configs.streaming_table import StreamingTableConfig
+from dbt.adapters.databricks.relation_configs.streaming_table import (
+    StreamingTableConfig,
+)
 from dbt.adapters.databricks.relation_configs.tblproperties import TblPropertiesConfig
+from dbt.tests import util
+from dbt.tests.adapter.materialized_view.files import (
+    MY_SEED,
+)
 from tests.functional.adapter.streaming_tables import fixtures
 
 
@@ -103,7 +106,13 @@ def test_full_refresh_occurs_with_changes(self, project, my_streaming_table):
         StreamingTableChanges.change_config_via_alter(project, my_streaming_table)
         StreamingTableChanges.change_config_via_replace(project, my_streaming_table)
         _, logs = util.run_dbt_and_capture(
-            ["--debug", "run", "--models", my_streaming_table.identifier, "--full-refresh"]
+            [
+                "--debug",
+                "run",
+                "--models",
+                my_streaming_table.identifier,
+                "--full-refresh",
+            ]
         )
         assert (
             StreamingTableChanges.query_relation_type(project, my_streaming_table)
diff --git a/tests/functional/adapter/tags/fixtures.py b/tests/functional/adapter/tags/fixtures.py
new file mode 100644
index 000000000..831dd7d73
--- /dev/null
+++ b/tests/functional/adapter/tags/fixtures.py
@@ -0,0 +1,30 @@
+tags_sql = """
+{{ config(
+    materialized = 'table',
+    databricks_tags = {'a': 'b', 'c': 'd'},
+) }}
+
+select cast(1 as bigint) as id, 'hello' as msg, 'blue' as color
+"""
+
+simple_python_model = """
+import pandas
+
+def model(dbt, spark):
+    dbt.config(
+        materialized='table',
+    )
+    data = [[1,2]] * 10
+    return spark.createDataFrame(data, schema=['test', 'test2'])
+"""
+
+python_schema = """version: 2
+models:
+  - name: tags
+    config:
+      tags: ["python"]
+      databricks_tags:
+        a: b
+        c: d
+      http_path: "{{ env_var('DBT_DATABRICKS_UC_CLUSTER_HTTP_PATH') }}"
+"""
diff --git a/tests/functional/adapter/tags/test_databricks_tags.py b/tests/functional/adapter/tags/test_databricks_tags.py
new file mode 100644
index 000000000..ae9f22651
--- /dev/null
+++ b/tests/functional/adapter/tags/test_databricks_tags.py
@@ -0,0 +1,46 @@
+import pytest
+from dbt.tests import util
+from tests.functional.adapter.tags import fixtures
+
+
+@pytest.mark.skip_profile("databricks_cluster")
+class TestTags:
+    @pytest.fixture(scope="class")
+    def models(self):
+        return {
+            "tags.sql": fixtures.tags_sql,
+        }
+
+    def test_tags(self, project):
+        _ = util.run_dbt(["run"])
+        _ = util.run_dbt(["run"])
+        results = project.run_sql(
+            "select tag_name, tag_value from {database}.information_schema.table_tags "
+            "where schema_name = '{schema}' and table_name='tags'",
+            fetch="all",
+        )
+        assert len(results) == 2
+
+
+@pytest.mark.skip_profile("databricks_cluster")
+class TestViewTags(TestTags):
+    @pytest.fixture(scope="class")
+    def models(self):
+        return {"tags.sql": fixtures.tags_sql.replace("table", "view")}
+
+
+@pytest.mark.skip_profile("databricks_cluster")
+class TestIncrementalTags(TestTags):
+    @pytest.fixture(scope="class")
+    def models(self):
+        return {"tags.sql": fixtures.tags_sql.replace("table", "incremental")}
+
+
+@pytest.mark.skip_profile("databricks_cluster")
+class TestPythonTags(TestTags):
+    @pytest.fixture(scope="class")
+    def models(self):
+        return {
+            "tags.py": fixtures.simple_python_model,
+            "schema.yml": fixtures.python_schema,
+        }
diff --git a/tests/functional/adapter/tblproperties/test_set_tblproperties.py b/tests/functional/adapter/tblproperties/test_set_tblproperties.py
index c470c810e..104db59e4 100644
--- a/tests/functional/adapter/tblproperties/test_set_tblproperties.py
+++ b/tests/functional/adapter/tblproperties/test_set_tblproperties.py
@@ -1,5 +1,7 @@
 from typing import List
+
 import pytest
+
 from dbt.tests import util
 from tests.functional.adapter.tblproperties import fixtures
 
diff --git a/tests/functional/adapter/unit_testing/test_types.py b/tests/functional/adapter/unit_testing/test_types.py
index f9cecf5a0..0b3b819f2 100644
--- a/tests/functional/adapter/unit_testing/test_types.py
+++ b/tests/functional/adapter/unit_testing/test_types.py
@@ -1,6 +1,7 @@
-from dbt.tests.adapter.unit_testing.test_types import BaseUnitTestingTypes
 import pytest
 
+from dbt.tests.adapter.unit_testing.test_types import BaseUnitTestingTypes
+
 
 class TestUnitTestingTypes(BaseUnitTestingTypes):
     @pytest.fixture
@@ -20,5 +21,8 @@ def data_types(self):
                 "map('10', 't', '15', 'f', '20', NULL)",
                 """'map("10", "t", "15", "f", "20", NULL)'""",
             ],
-            ['named_struct("a", 1, "b", 2, "c", 3)', """'named_struct("a", 1, "b", 2, "c", 3)'"""],
+            [
+                'named_struct("a", 1, "b", 2, "c", 3)',
+                """'named_struct("a", 1, "b", 2, "c", 3)'""",
+            ],
         ]
diff --git a/tests/functional/adapter/utils/test_data_types.py b/tests/functional/adapter/utils/test_data_types.py
index 8ca38ab1e..1e3b3b1d8 100644
--- a/tests/functional/adapter/utils/test_data_types.py
+++ b/tests/functional/adapter/utils/test_data_types.py
@@ -1,17 +1,18 @@
 import pytest
+
 from dbt.tests.adapter.utils.data_types.test_type_bigint import BaseTypeBigInt
+from dbt.tests.adapter.utils.data_types.test_type_boolean import BaseTypeBoolean
+from dbt.tests.adapter.utils.data_types.test_type_float import BaseTypeFloat
 from dbt.tests.adapter.utils.data_types.test_type_float import (
-    BaseTypeFloat,
     seeds__expected_csv as seeds__float_expected_csv,
 )
+from dbt.tests.adapter.utils.data_types.test_type_int import BaseTypeInt
 from dbt.tests.adapter.utils.data_types.test_type_int import (
-    BaseTypeInt,
     seeds__expected_csv as seeds__int_expected_csv,
 )
 from dbt.tests.adapter.utils.data_types.test_type_numeric import BaseTypeNumeric
 from dbt.tests.adapter.utils.data_types.test_type_string import BaseTypeString
 from dbt.tests.adapter.utils.data_types.test_type_timestamp import BaseTypeTimestamp
-from dbt.tests.adapter.utils.data_types.test_type_boolean import BaseTypeBoolean
 
 
 class TestTypeBigInt(BaseTypeBigInt):
diff --git a/tests/functional/adapter/utils/test_dateadd.py b/tests/functional/adapter/utils/test_dateadd.py
index 05a8d10b5..6d214b708 100644
--- a/tests/functional/adapter/utils/test_dateadd.py
+++ b/tests/functional/adapter/utils/test_dateadd.py
@@ -1,7 +1,8 @@
-from dbt.tests.adapter.utils.test_dateadd import BaseDateAdd
 import pytest
+
 import dbt.tests.adapter.utils.fixture_dateadd as fixtures
 import tests.functional.adapter.utils.fixture_dateadd as fixture_overrides
+from dbt.tests.adapter.utils.test_dateadd import BaseDateAdd
 
 
 class TestDateAdd(BaseDateAdd):
diff --git a/tests/functional/adapter/utils/test_get_intervals_between.py b/tests/functional/adapter/utils/test_get_intervals_between.py
index 78ad0546c..880fbf70c 100644
--- a/tests/functional/adapter/utils/test_get_intervals_between.py
+++ b/tests/functional/adapter/utils/test_get_intervals_between.py
@@ -1,8 +1,9 @@
-from dbt.tests.adapter.utils.test_get_intervals_between import BaseGetIntervalsBetween
+import pytest
+
 from dbt.tests.adapter.utils.fixture_get_intervals_between import (
     models__test_get_intervals_between_yml,
 )
-import pytest
+from dbt.tests.adapter.utils.test_get_intervals_between import BaseGetIntervalsBetween
 
 
 class TestDatabricksGetIntervalBetween(BaseGetIntervalsBetween):
diff --git a/tests/functional/adapter/utils/test_listagg.py b/tests/functional/adapter/utils/test_listagg.py
index 83e26b236..112ca6d9b 100644
--- a/tests/functional/adapter/utils/test_listagg.py
+++ b/tests/functional/adapter/utils/test_listagg.py
@@ -1,8 +1,9 @@
 # requires modification
-from dbt.tests.adapter.utils.test_listagg import BaseListagg
-import dbt.tests.adapter.utils.fixture_listagg as fixtures
 import pytest
+
+import dbt.tests.adapter.utils.fixture_listagg as fixtures
 import tests.functional.adapter.utils.fixture_listagg as fixture_overrides
+from dbt.tests.adapter.utils.test_listagg import BaseListagg
 
 
 # SparkSQL does not support 'order by' for its 'listagg' equivalent
diff --git a/tests/functional/adapter/utils/test_source_freshness.py b/tests/functional/adapter/utils/test_source_freshness.py
index ea8091571..5b2024c73 100644
--- a/tests/functional/adapter/utils/test_source_freshness.py
+++ b/tests/functional/adapter/utils/test_source_freshness.py
@@ -1,7 +1,9 @@
 import os
+
 import pytest
 
-from dbt.tests.util import get_artifact, run_dbt
+from dbt.tests.util import get_artifact
+from dbt.tests.util import run_dbt
 
 freshness_via_metadata_schema_yml = """
 version: 2
@@ -31,7 +33,8 @@ def models(self):
     def custom_schema(self, project, set_env_vars):
         with project.adapter.connection_named("__test"):
             relation = project.adapter.Relation.create(
-                database=project.database, schema=os.environ["DBT_GET_RELATION_TEST_SCHEMA"]
+                database=project.database,
+                schema=os.environ["DBT_GET_RELATION_TEST_SCHEMA"],
             )
             project.adapter.drop_schema(relation)
             project.adapter.create_schema(relation)
diff --git a/tests/functional/adapter/utils/test_timestamps.py b/tests/functional/adapter/utils/test_timestamps.py
index c7d2ebe52..473e0151e 100644
--- a/tests/functional/adapter/utils/test_timestamps.py
+++ b/tests/functional/adapter/utils/test_timestamps.py
@@ -1,4 +1,5 @@
 import pytest
+
 from dbt.tests.adapter.utils.test_timestamps import BaseCurrentTimestamps
 
 
diff --git a/tests/functional/adapter/utils/test_utils.py b/tests/functional/adapter/utils/test_utils.py
index cb9580f11..a6b99634b 100644
--- a/tests/functional/adapter/utils/test_utils.py
+++ b/tests/functional/adapter/utils/test_utils.py
@@ -1,16 +1,18 @@
+from dbt.tests.adapter.utils.test_any_value import BaseAnyValue
 from dbt.tests.adapter.utils.test_array_append import BaseArrayAppend
 from dbt.tests.adapter.utils.test_array_concat import BaseArrayConcat
 from dbt.tests.adapter.utils.test_array_construct import BaseArrayConstruct
-from dbt.tests.adapter.utils.test_any_value import BaseAnyValue
 from dbt.tests.adapter.utils.test_bool_or import BaseBoolOr
 from dbt.tests.adapter.utils.test_cast_bool_to_text import BaseCastBoolToText
 from dbt.tests.adapter.utils.test_concat import BaseConcat
 from dbt.tests.adapter.utils.test_current_timestamp import BaseCurrentTimestampAware
 from dbt.tests.adapter.utils.test_date_spine import BaseDateSpine
-from dbt.tests.adapter.utils.test_datediff import BaseDateDiff
 from dbt.tests.adapter.utils.test_date_trunc import BaseDateTrunc
+from dbt.tests.adapter.utils.test_datediff import BaseDateDiff
 from dbt.tests.adapter.utils.test_equals import BaseEquals
-from dbt.tests.adapter.utils.test_escape_single_quotes import BaseEscapeSingleQuotesBackslash
+from dbt.tests.adapter.utils.test_escape_single_quotes import (
+    BaseEscapeSingleQuotesBackslash,
+)
 from dbt.tests.adapter.utils.test_except import BaseExcept
 from dbt.tests.adapter.utils.test_generate_series import BaseGenerateSeries
 from dbt.tests.adapter.utils.test_get_powers_of_two import BaseGetPowersOfTwo
@@ -18,7 +20,8 @@
 from dbt.tests.adapter.utils.test_intersect import BaseIntersect
 from dbt.tests.adapter.utils.test_last_day import BaseLastDay
 from dbt.tests.adapter.utils.test_length import BaseLength
-from dbt.tests.adapter.utils.test_null_compare import BaseMixedNullCompare, BaseNullCompare
+from dbt.tests.adapter.utils.test_null_compare import BaseMixedNullCompare
+from dbt.tests.adapter.utils.test_null_compare import BaseNullCompare
 from dbt.tests.adapter.utils.test_position import BasePosition
 from dbt.tests.adapter.utils.test_replace import BaseReplace
 from dbt.tests.adapter.utils.test_right import BaseRight
diff --git a/tests/functional/adapter/warehouse_per_model/test_warehouse_per_model.py b/tests/functional/adapter/warehouse_per_model/test_warehouse_per_model.py
index efc1dd8b8..cf309fa3f 100644
--- a/tests/functional/adapter/warehouse_per_model/test_warehouse_per_model.py
+++ b/tests/functional/adapter/warehouse_per_model/test_warehouse_per_model.py
@@ -1,4 +1,5 @@
 import pytest
+
 from dbt.tests import util
 from tests.functional.adapter.warehouse_per_model import fixtures
 
@@ -117,7 +118,11 @@ def test_wpm(self, project, profile_dir):
                 "alternate_warehouse",
             ]
         )
-        assert "`source` using compute resource 'alternate_warehouse2'" in log
+
+        assert (
+            "using compute resource 'alternate_warehouse2' for model "
+            f"'`{project.database}`.`{project.test_schema}`.`source`'" in log
+        )
 
         _, log = util.run_dbt_and_capture(
             [
@@ -132,8 +137,14 @@ def test_wpm(self, project, profile_dir):
                 "alternate_warehouse",
             ]
         )
-        assert "`target` using compute resource 'alternate_warehouse'" in log
-        assert "`target3` using default compute resource" in log
+        assert (
+            "using compute resource 'alternate_warehouse' for model "
+            f"'`{project.database}`.`{project.test_schema}`.`target`'" in log
+        )
+        assert (
+            f"using default compute resource for model '`{project.database}`."
+            f"`{project.test_schema}`.`target3`'" in log
+        )
 
         _, log = util.run_dbt_and_capture(
             [
@@ -145,6 +156,9 @@ def test_wpm(self, project, profile_dir):
                 "alternate_warehouse",
             ]
         )
-        assert "`target_snap` using compute resource 'alternate_warehouse3'" in log
+        assert (
+            "using compute resource 'alternate_warehouse3' for model "
+            f"'`{project.database}`.`snapshots`.`target_snap`'" in log
+        )
 
         util.check_relations_equal(project.adapter, ["target", "source"])
diff --git a/tests/functional/adapter/zorder/test_zorder.py b/tests/functional/adapter/zorder/test_zorder.py
index b835a5f61..e6c1279f9 100644
--- a/tests/functional/adapter/zorder/test_zorder.py
+++ b/tests/functional/adapter/zorder/test_zorder.py
@@ -1,4 +1,5 @@
 import pytest
+
 from dbt.tests import util
 from tests.functional.adapter.zorder import fixtures
 
diff --git a/tests/profiles.py b/tests/profiles.py
index c00cb8985..417688615 100644
--- a/tests/profiles.py
+++ b/tests/profiles.py
@@ -1,5 +1,7 @@
 import os
-from typing import Any, Dict, Optional
+from typing import Any
+from typing import Dict
+from typing import Optional
 
 
 def get_databricks_cluster_target(profile_type: str):
diff --git a/tests/unit/events/test_base_events.py b/tests/unit/events/test_base_events.py
new file mode 100644
index 000000000..85724eba8
--- /dev/null
+++ b/tests/unit/events/test_base_events.py
@@ -0,0 +1,34 @@
+from databricks.sql.exc import Error
+from dbt.adapters.databricks.events.base import ErrorEvent
+from dbt.adapters.databricks.events.base import SQLErrorEvent
+
+
+class ErrorTestEvent(ErrorEvent):
+    def __init__(self, exception):
+        super().__init__(exception, "This is a test")
+
+
+class TestErrorEvent:
+    def test_error_event__without_exception(self):
+        event = ErrorTestEvent(None)
+        assert str(event) == "This is a test: None"
+
+    def test_error_event__with_exception(self):
+        e = Exception("This is an exception")
+        event = ErrorTestEvent(e)
+        assert str(event) == "This is a test: This is an exception"
+
+
+class TestSQLErrorEvent:
+    def test_sql_error_event__with_exception(self):
+        e = Exception("This is an exception")
+        event = SQLErrorEvent(e, "This is a test")
+        assert str(event) == "This is a test: This is an exception"
+
+    def test_sql_error_event__with_pysql_error(self):
+        e = Error("This is a pysql error", {"key": "value", "other": "other_value"})
+        event = SQLErrorEvent(e, "This is a test")
+        assert (
+            str(event) == "This is a test: This is a pysql error\n"
+            "Error properties: key=value, other=other_value"
+        )
diff --git a/tests/unit/events/test_connection_events.py b/tests/unit/events/test_connection_events.py
new file mode 100644
index 000000000..6e1c8bb34
--- /dev/null
+++ b/tests/unit/events/test_connection_events.py
@@ -0,0 +1,71 @@
+from dbt.adapters.databricks.events.connection_events import ConnectionAcquire
+from dbt.adapters.databricks.events.connection_events import ConnectionCloseError
+from dbt.adapters.databricks.events.connection_events import ConnectionEvent
+from mock import Mock
+
+
+class ConnectionTestEvent(ConnectionEvent):
+    def __init__(self, connection):
+        super().__init__(connection, "This is a test")
+
+
+class TestConnectionEvents:
+    def test_cursor_event__no_connection(self):
+        event = ConnectionTestEvent(None)
+        assert str(event) == "Connection(session-id=Unknown) - This is a test"
+
+    def test_connection_event__no_id(self):
+        mock = Mock()
+        mock.get_session_id_hex.return_value = None
+        event = ConnectionTestEvent(mock)
+        assert str(event) == "Connection(session-id=Unknown) - This is a test"
+
+    def test_connection_event__with_id(self):
+        mock = Mock()
+        mock.get_session_id_hex.return_value = "1234"
+        event = ConnectionTestEvent(mock)
+        assert str(event) == "Connection(session-id=1234) - This is a test"
+
+
+class TestConnectionCloseError:
+    def test_connection_close_error(self):
+        e = Exception("This is an exception")
+        event = ConnectionCloseError(None, e)
+        assert (
+            str(event) == "Connection(session-id=Unknown) "
+            "- Exception while trying to close connection: This is an exception"
+        )
+
+
+class TestConnectionAcquire:
+    def test_connection_acquire__missing_data(self):
+        event = ConnectionAcquire(None, None, None, (0, 0))
+        assert (
+            str(event)
+            == "None - Acquired connection on thread (0, 0), using default compute resource"
+        )
+
+    def test_connection_acquire__with_compute_name(self):
+        event = ConnectionAcquire(None, None, "Eniac", (0, 0))
+        assert (
+            str(event)
+            == "None - Acquired connection on thread (0, 0), using compute resource 'Eniac'"
+        )
+
+    def test_connection_acquire__with_nonmodel_node(self):
+        event = ConnectionAcquire(None, Mock([]), None, (0, 0))
+        assert (
+            str(event)
+            == "None - Acquired connection on thread (0, 0), using default compute resource"
+            " for model '[Unknown]'"
+        )
+
+    def test_connection_acquire__with_everything(self):
+        model = Mock()
+        model.relation_name = "MyModel"
+        event = ConnectionAcquire("Connection", model, "Eniac", (0, 0))
+        assert (
+            str(event)
+            == "Connection - Acquired connection on thread (0, 0), using compute resource 'Eniac'"
+            " for model 'MyModel'"
+        )
diff --git a/tests/unit/events/test_cursor_events.py b/tests/unit/events/test_cursor_events.py
new file mode 100644
index 000000000..0a767af1d
--- /dev/null
+++ b/tests/unit/events/test_cursor_events.py
@@ -0,0 +1,41 @@
+from dbt.adapters.databricks.events.cursor_events import CursorCloseError
+from dbt.adapters.databricks.events.cursor_events import CursorEvent
+from mock import Mock
+
+
+class CursorTestEvent(CursorEvent):
+    def __init__(self, cursor):
+        super().__init__(cursor, "This is a test")
+
+
+class TestCursorEvents:
+    def test_cursor_event__no_cursor(self):
+        event = CursorTestEvent(None)
+        assert str(event) == "Cursor(session-id=Unknown, command-id=Unknown) - This is a test"
+
+    def test_cursor_event__no_ids(self):
+        mock = Mock()
+        mock.connection = None
+        mock.active_result_set = None
+        event = CursorTestEvent(mock)
+        assert str(event) == "Cursor(session-id=Unknown, command-id=Unknown) - This is a test"
+
+    def test_cursor_event__with_ids(self):
+        mock = Mock()
+        mock.connection.get_session_id_hex.return_value = "1234"
+        mock.active_result_set.command_id.operationId.guid = (1234).to_bytes(16, "big")
+        event = CursorTestEvent(mock)
+        assert (
+            str(event) == "Cursor(session-id=1234, command-id=00000000-0000-0000-0000-0000000004d2)"
+            " - This is a test"
+        )
+
+
+class TestCursorCloseError:
+    def test_cursor_close_error(self):
+        e = Exception("This is an exception")
+        event = CursorCloseError(None, e)
+        assert (
+            str(event) == "Cursor(session-id=Unknown, command-id=Unknown) "
+            "- Exception while trying to close cursor: This is an exception"
+        )
diff --git a/tests/unit/macros/adapters/test_python_macros.py b/tests/unit/macros/adapters/test_python_macros.py
index 0a5f931ce..0a8c655c9 100644
--- a/tests/unit/macros/adapters/test_python_macros.py
+++ b/tests/unit/macros/adapters/test_python_macros.py
@@ -1,8 +1,8 @@
+import pytest
 from jinja2 import Template
 from mock import MagicMock
-from tests.unit.macros.base import MacroTestBase
 
-import pytest
+from tests.unit.macros.base import MacroTestBase
 
 
 class TestPythonMacros(MacroTestBase):
diff --git a/tests/unit/macros/base.py b/tests/unit/macros/base.py
index cf8025929..e17f2aec4 100644
--- a/tests/unit/macros/base.py
+++ b/tests/unit/macros/base.py
@@ -1,8 +1,14 @@
 import re
-from typing import Any, Dict
-from mock import Mock
+from typing import Any
+from typing import Dict
+
 import pytest
-from jinja2 import Environment, FileSystemLoader, PackageLoader, Template
+from jinja2 import Environment
+from jinja2 import FileSystemLoader
+from jinja2 import PackageLoader
+from jinja2 import Template
+from mock import Mock
+
 from dbt.adapters.databricks.relation import DatabricksRelation
 
 
diff --git a/tests/unit/macros/relations/test_incremental_macros.py b/tests/unit/macros/relations/test_incremental_macros.py
index a7de50cbb..d966fc5d5 100644
--- a/tests/unit/macros/relations/test_incremental_macros.py
+++ b/tests/unit/macros/relations/test_incremental_macros.py
@@ -16,7 +16,11 @@ def render_update_set(
         self, template, update_columns=[], on_schema_change="ignore", source_columns=[]
     ):
         return self.run_macro_raw(
-            template, "get_merge_update_set", update_columns, on_schema_change, source_columns
+            template,
+            "get_merge_update_set",
+            update_columns,
+            on_schema_change,
+            source_columns,
         )
 
     def test_get_merge_update_set__update_columns(self, template):
@@ -77,7 +81,12 @@ def macro_folders_to_load(self) -> list:
 
     def render_insert_into(self, template, dest_columns=["a"], source_columns=["a"]):
         return self.run_macro_raw(
-            template, "insert_into_sql_impl", "target", dest_columns, "source", source_columns
+            template,
+            "insert_into_sql_impl",
+            "target",
+            dest_columns,
+            "source",
+            source_columns,
         )
 
     def test_insert_into_sql_impl__matching_columns(self, template):
diff --git a/tests/unit/macros/relations/test_tags_macros.py b/tests/unit/macros/relations/test_tags_macros.py
new file mode 100644
index 000000000..bfed194c1
--- /dev/null
+++ b/tests/unit/macros/relations/test_tags_macros.py
@@ -0,0 +1,36 @@
+import pytest
+from tests.unit.macros.base import MacroTestBase
+
+
+class TestTagsMacros(MacroTestBase):
+    @pytest.fixture
+    def template_name(self) -> str:
+        return "tags.sql"
+
+    @pytest.fixture(scope="class")
+    def macro_folders_to_load(self) -> list:
+        return ["macros/relations", "macros"]
+
+    def test_macros_fetch_tags_sql(self, template_bundle):
+        sql = self.render_bundle(template_bundle, "fetch_tags_sql")
+        expected = (
+            "SELECT tag_name, tag_value "
+            "FROM `some_database`.`information_schema`.`table_tags` "
+            "WHERE schema_name = 'some_schema' AND table_name = 'some_table'"
+        )
+        assert sql == expected
+
+    def test_macros_alter_set_tags(self, template_bundle):
+        sql = self.render_bundle(template_bundle, "alter_set_tags", {"a": "valA", "b": "valB"})
+        expected = (
+            "ALTER None `some_database`.`some_schema`.`some_table` "
+            "SET TAGS ( 'a' = 'valA', 'b' = 'valB' )"
+        )
+
+        assert sql == expected
+
+    def test_macros_alter_unset_tags(self, template_bundle):
+        sql = self.render_bundle(template_bundle, "alter_unset_tags", ["a", "b"])
+        expected = "ALTER None `some_database`.`some_schema`.`some_table` UNSET TAGS ( 'a','b' )"
+
+        assert sql == expected
diff --git a/tests/unit/macros/relations/test_view_macros.py b/tests/unit/macros/relations/test_view_macros.py
index 7bd3cba78..39f2912e0 100644
--- a/tests/unit/macros/relations/test_view_macros.py
+++ b/tests/unit/macros/relations/test_view_macros.py
@@ -1,5 +1,5 @@
-from mock import Mock
 import pytest
+from mock import Mock
 
 from tests.unit.macros.base import MacroTestBase
 
diff --git a/tests/unit/python/test_python_submissions.py b/tests/unit/python/test_python_submissions.py
index e3a6f5741..27f1eb5f4 100644
--- a/tests/unit/python/test_python_submissions.py
+++ b/tests/unit/python/test_python_submissions.py
@@ -1,9 +1,9 @@
 import unittest
 from unittest.mock import Mock
 
-from dbt.adapters.databricks.connections import DatabricksCredentials
-
-from dbt.adapters.databricks.python_submissions import DBContext, BaseDatabricksHelper
+from dbt.adapters.databricks.credentials import DatabricksCredentials
+from dbt.adapters.databricks.python_submissions import BaseDatabricksHelper
+from dbt.adapters.databricks.python_submissions import DBContext
 
 
 class TestDatabricksPythonSubmissions(unittest.TestCase):
diff --git a/tests/unit/relation_configs/test_comment.py b/tests/unit/relation_configs/test_comment.py
index 175eb1d37..ef666fc4b 100644
--- a/tests/unit/relation_configs/test_comment.py
+++ b/tests/unit/relation_configs/test_comment.py
@@ -1,6 +1,8 @@
-from mock import Mock
 from agate import Table
-from dbt.adapters.databricks.relation_configs.comment import CommentConfig, CommentProcessor
+from mock import Mock
+
+from dbt.adapters.databricks.relation_configs.comment import CommentConfig
+from dbt.adapters.databricks.relation_configs.comment import CommentProcessor
 
 
 class TestCommentProcessor:
diff --git a/tests/unit/relation_configs/test_incremental_config.py b/tests/unit/relation_configs/test_incremental_config.py
new file mode 100644
index 000000000..ec919b082
--- /dev/null
+++ b/tests/unit/relation_configs/test_incremental_config.py
@@ -0,0 +1,25 @@
+from agate import Table
+
+from dbt.adapters.databricks.relation_configs.incremental import IncrementalTableConfig
+from dbt.adapters.databricks.relation_configs.tags import TagsConfig
+
+
+class TestIncrementalConfig:
+    def test_from_results(self):
+        results = {
+            "information_schema.tags": Table(
+                rows=[
+                    ["tag1", "value1"],
+                    ["tag2", "value2"],
+                ],
+                column_names=["tag_name", "tag_value"],
+            )
+        }
+
+        config = IncrementalTableConfig.from_results(results)
+
+        assert config == IncrementalTableConfig(
+            config={
+                "tags": TagsConfig(set_tags={"tag1": "value1", "tag2": "value2"}),
+            }
+        )
diff --git a/tests/unit/relation_configs/test_materialized_view_config.py b/tests/unit/relation_configs/test_materialized_view_config.py
index c055b4e69..da2b1ff35 100644
--- a/tests/unit/relation_configs/test_materialized_view_config.py
+++ b/tests/unit/relation_configs/test_materialized_view_config.py
@@ -1,11 +1,14 @@
-from agate import Table, Row
-from mock import Mock
+from agate import Row
+from agate import Table
 from dbt.adapters.databricks.relation_configs.comment import CommentConfig
-from dbt.adapters.databricks.relation_configs.materialized_view import MaterializedViewConfig
+from dbt.adapters.databricks.relation_configs.materialized_view import (
+    MaterializedViewConfig,
+)
 from dbt.adapters.databricks.relation_configs.partitioning import PartitionedByConfig
 from dbt.adapters.databricks.relation_configs.query import QueryConfig
 from dbt.adapters.databricks.relation_configs.refresh import RefreshConfig
 from dbt.adapters.databricks.relation_configs.tblproperties import TblPropertiesConfig
+from mock import Mock
 
 
 class TestMaterializedViewConfig:
diff --git a/tests/unit/relation_configs/test_partitioning.py b/tests/unit/relation_configs/test_partitioning.py
index 3a27586d8..14bb36d4c 100644
--- a/tests/unit/relation_configs/test_partitioning.py
+++ b/tests/unit/relation_configs/test_partitioning.py
@@ -1,10 +1,8 @@
-from mock import Mock
 from agate import Table
+from mock import Mock
 
-from dbt.adapters.databricks.relation_configs.partitioning import (
-    PartitionedByConfig,
-    PartitionedByProcessor,
-)
+from dbt.adapters.databricks.relation_configs.partitioning import PartitionedByConfig
+from dbt.adapters.databricks.relation_configs.partitioning import PartitionedByProcessor
 
 
 class TestPartitionedByProcessor:
diff --git a/tests/unit/relation_configs/test_query.py b/tests/unit/relation_configs/test_query.py
index 2434cc50b..20ee9d181 100644
--- a/tests/unit/relation_configs/test_query.py
+++ b/tests/unit/relation_configs/test_query.py
@@ -1,8 +1,10 @@
+import pytest
 from agate import Row
 from mock import Mock
-import pytest
+
+from dbt.adapters.databricks.relation_configs.query import QueryConfig
+from dbt.adapters.databricks.relation_configs.query import QueryProcessor
 from dbt.exceptions import DbtRuntimeError
-from dbt.adapters.databricks.relation_configs.query import QueryConfig, QueryProcessor
 
 sql = "select * from foo"
 
diff --git a/tests/unit/relation_configs/test_refresh.py b/tests/unit/relation_configs/test_refresh.py
index a1208c993..f60474855 100644
--- a/tests/unit/relation_configs/test_refresh.py
+++ b/tests/unit/relation_configs/test_refresh.py
@@ -1,12 +1,13 @@
-from typing import Any, List
-from mock import Mock
+from typing import Any
+from typing import List
+
 import pytest
-from dbt.adapters.databricks.relation_configs.refresh import (
-    RefreshProcessor,
-    RefreshConfig,
-)
-from dbt.exceptions import DbtRuntimeError
 from agate import Table
+from mock import Mock
+
+from dbt.adapters.databricks.relation_configs.refresh import RefreshConfig
+from dbt.adapters.databricks.relation_configs.refresh import RefreshProcessor
+from dbt.exceptions import DbtRuntimeError
 
 
 class TestRefreshProcessor:
diff --git a/tests/unit/relation_configs/test_streaming_table_config.py b/tests/unit/relation_configs/test_streaming_table_config.py
index c990bce1a..36552268e 100644
--- a/tests/unit/relation_configs/test_streaming_table_config.py
+++ b/tests/unit/relation_configs/test_streaming_table_config.py
@@ -1,9 +1,12 @@
 from agate import Table
 from mock import Mock
+
 from dbt.adapters.databricks.relation_configs.comment import CommentConfig
-from dbt.adapters.databricks.relation_configs.streaming_table import StreamingTableConfig
 from dbt.adapters.databricks.relation_configs.partitioning import PartitionedByConfig
 from dbt.adapters.databricks.relation_configs.refresh import RefreshConfig
+from dbt.adapters.databricks.relation_configs.streaming_table import (
+    StreamingTableConfig,
+)
 from dbt.adapters.databricks.relation_configs.tblproperties import TblPropertiesConfig
 
 
diff --git a/tests/unit/relation_configs/test_tags.py b/tests/unit/relation_configs/test_tags.py
new file mode 100644
index 000000000..adf5d27fe
--- /dev/null
+++ b/tests/unit/relation_configs/test_tags.py
@@ -0,0 +1,66 @@
+import pytest
+from agate import Table
+from dbt.adapters.databricks.relation_configs.tags import TagsConfig
+from dbt.adapters.databricks.relation_configs.tags import TagsProcessor
+from dbt.exceptions import DbtRuntimeError
+from mock import Mock
+
+
+class TestTagsProcessor:
+    def test_from_relation_results__none(self):
+        results = {
+            "information_schema.tags": Table(rows=[], column_names=["tag_name", "tag_value"])
+        }
+        spec = TagsProcessor.from_relation_results(results)
+        assert spec == TagsConfig(set_tags={})
+
+    def test_from_relation_results__some(self):
+        results = {
+            "information_schema.tags": Table(
+                rows=[["a", "valA"], ["b", "valB"]], column_names=["tag_name", "tag_value"]
+            )
+        }
+        spec = TagsProcessor.from_relation_results(results)
+        assert spec == TagsConfig(set_tags={"a": "valA", "b": "valB"})
+
+    def test_from_relation_config__without_tags(self):
+        model = Mock()
+        model.config.extra = {}
+        spec = TagsProcessor.from_relation_config(model)
+        assert spec == TagsConfig(set_tags={})
+
+    def test_from_relation_config__with_tags(self):
+        model = Mock()
+        model.config.extra = {"databricks_tags": {"a": "valA", "b": 1}}
+        spec = TagsProcessor.from_relation_config(model)
+        assert spec == TagsConfig(set_tags={"a": "valA", "b": "1"})
+
+    def test_from_relation_config__with_incorrect_tags(self):
+        model = Mock()
+        model.config.extra = {"databricks_tags": ["a", "b"]}
+
+        with pytest.raises(
+            DbtRuntimeError,
+            match="databricks_tags must be a dictionary",
+        ):
+            _ = TagsProcessor.from_relation_config(model)
+
+
+class TestTagsConfig:
+    def test_get_diff__empty_and_some_exist(self):
+        config = TagsConfig(set_tags={})
+        other = TagsConfig(set_tags={"tag": "value"})
+        diff = config.get_diff(other)
+        assert diff == TagsConfig(set_tags={}, unset_tags=["tag"])
+
+    def test_get_diff__some_new_and_empty_existing(self):
+        config = TagsConfig(set_tags={"tag": "value"})
+        other = TagsConfig(set_tags={})
+        diff = config.get_diff(other)
+        assert diff == TagsConfig(set_tags={"tag": "value"}, unset_tags=[])
+
+    def test_get_diff__mixed_case(self):
+        config = TagsConfig(set_tags={"a": "value", "b": "value"})
+        other = TagsConfig(set_tags={"b": "other_value", "c": "value"})
+        diff = config.get_diff(other)
+        assert diff == TagsConfig(set_tags={"a": "value", "b": "value"}, unset_tags=["c"])
diff --git a/tests/unit/relation_configs/test_tblproperties.py b/tests/unit/relation_configs/test_tblproperties.py
index d86cdae44..a9d78d66c 100644
--- a/tests/unit/relation_configs/test_tblproperties.py
+++ b/tests/unit/relation_configs/test_tblproperties.py
@@ -1,12 +1,11 @@
-from mock import Mock
 import pytest
 from agate import Table
-
+from dbt.adapters.databricks.relation_configs.tblproperties import TblPropertiesConfig
 from dbt.adapters.databricks.relation_configs.tblproperties import (
-    TblPropertiesConfig,
     TblPropertiesProcessor,
 )
 from dbt.exceptions import DbtRuntimeError
+from mock import Mock
 
 
 class TestTblPropertiesProcessor:
diff --git a/tests/unit/test_adapter.py b/tests/unit/test_adapter.py
index 26f0d9936..2c7ca4ee9 100644
--- a/tests/unit/test_adapter.py
+++ b/tests/unit/test_adapter.py
@@ -1,26 +1,26 @@
-from typing import Any, Dict, Optional
 import unittest
-from unittest import mock
 from multiprocessing import get_context
-from agate import Row
-import dbt.flags as flags
-import dbt.adapters.exceptions
-from dbt.config import RuntimeConfig
+from typing import Any
+from typing import Dict
+from typing import Optional
+from unittest import mock
 
+import dbt.adapters.exceptions
+import dbt.flags as flags
+import pytest
+from agate import Row
 from dbt.adapters.databricks import __version__
-from dbt.adapters.databricks import DatabricksAdapter, DatabricksRelation
+from dbt.adapters.databricks import DatabricksAdapter
+from dbt.adapters.databricks import DatabricksRelation
 from dbt.adapters.databricks.column import DatabricksColumn
+from dbt.adapters.databricks.credentials import CATALOG_KEY_IN_SESSION_PROPERTIES
+from dbt.adapters.databricks.credentials import DBT_DATABRICKS_HTTP_SESSION_HEADERS
+from dbt.adapters.databricks.credentials import DBT_DATABRICKS_INVOCATION_ENV
 from dbt.adapters.databricks.impl import check_not_found_error
 from dbt.adapters.databricks.impl import get_identifier_list_string
-from dbt.adapters.databricks.connections import (
-    CATALOG_KEY_IN_SESSION_PROPERTIES,
-    DBT_DATABRICKS_INVOCATION_ENV,
-    DBT_DATABRICKS_HTTP_SESSION_HEADERS,
-)
+from dbt.config import RuntimeConfig
 from tests.unit.utils import config_from_parts_or_dicts
 
-import pytest
-
 
 class DatabricksAdapterBase:
     def setUp(self):
@@ -383,9 +383,17 @@ def test_parse_relation(self):
             ("Type", "MANAGED", None),
             ("Provider", "delta", None),
             ("Location", "/mnt/vo", None),
-            ("Serde Library", "org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe", None),
+            (
+                "Serde Library",
+                "org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe",
+                None,
+            ),
             ("InputFormat", "org.apache.hadoop.mapred.SequenceFileInputFormat", None),
-            ("OutputFormat", "org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat", None),
+            (
+                "OutputFormat",
+                "org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat",
+                None,
+            ),
             ("Partition Provider", "Catalog", None),
         ]
 
@@ -543,9 +551,17 @@ def test_parse_relation_with_statistics(self):
             ("Type", "MANAGED", None),
             ("Provider", "delta", None),
             ("Location", "/mnt/vo", None),
-            ("Serde Library", "org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe", None),
+            (
+                "Serde Library",
+                "org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe",
+                None,
+            ),
             ("InputFormat", "org.apache.hadoop.mapred.SequenceFileInputFormat", None),
-            ("OutputFormat", "org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat", None),
+            (
+                "OutputFormat",
+                "org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat",
+                None,
+            ),
             ("Partition Provider", "Catalog", None),
         ]
 
@@ -885,7 +901,8 @@ def test_describe_table_extended_2048_char_limit(self):
 
             # Short list of table names is not capped
             self.assertEqual(
-                get_identifier_list_string(list(table_names)[:5]), "|".join(list(table_names)[:5])
+                get_identifier_list_string(list(table_names)[:5]),
+                "|".join(list(table_names)[:5]),
             )
 
     def test_describe_table_extended_should_not_limit(self):
@@ -924,7 +941,8 @@ def test_describe_table_extended_may_limit(self):
         with mock.patch.dict("os.environ", **{"DBT_DESCRIBE_TABLE_2048_CHAR_BYPASS": "true"}):
             # But a short list of table names is not capped
             self.assertEqual(
-                get_identifier_list_string(list(table_names)[:5]), "|".join(list(table_names)[:5])
+                get_identifier_list_string(list(table_names)[:5]),
+                "|".join(list(table_names)[:5]),
             )
 
 
@@ -982,7 +1000,10 @@ def test_get_persist_doc_columns_partial_match(self, adapter):
         assert adapter.get_persist_doc_columns(existing, column_dict) == column_dict
 
     def test_get_persist_doc_columns_mixed(self, adapter):
-        existing = [self.create_column("col1", "comment1"), self.create_column("col2", "comment2")]
+        existing = [
+            self.create_column("col1", "comment1"),
+            self.create_column("col2", "comment2"),
+        ]
         column_dict = {
             "col1": {"name": "col1", "description": "comment2"},
             "col2": {"name": "col2", "description": "comment2"},
diff --git a/tests/unit/test_auth.py b/tests/unit/test_auth.py
index 06daf071d..cd2f171c0 100644
--- a/tests/unit/test_auth.py
+++ b/tests/unit/test_auth.py
@@ -1,8 +1,10 @@
 import unittest
-from dbt.adapters.databricks.connections import DatabricksCredentials
+
 import keyring.backend
 import pytest
 
+from dbt.adapters.databricks.credentials import DatabricksCredentials
+
 
 @pytest.mark.skip(reason="Need to mock requests to OIDC")
 class TestM2MAuth(unittest.TestCase):
@@ -57,7 +59,11 @@ class TestTokenAuth(unittest.TestCase):
     def test_token(self):
         host = "my.cloud.databricks.com"
         creds = DatabricksCredentials(
-            host=host, token="foo", database="andre", http_path="http://foo", schema="dbt"
+            host=host,
+            token="foo",
+            database="andre",
+            http_path="http://foo",
+            schema="dbt",
         )
         provider = creds.authenticate(None)
         self.assertIsNotNone(provider)
@@ -84,7 +90,11 @@ def test_store_and_delete_short_password(self):
         long_password = "x" * 10
 
         creds = DatabricksCredentials(
-            host=host, token="foo", database="andre", http_path="http://foo", schema="dbt"
+            host=host,
+            token="foo",
+            database="andre",
+            http_path="http://foo",
+            schema="dbt",
         )
         creds.set_sharded_password(service, host, long_password)
 
@@ -105,7 +115,11 @@ def test_store_and_delete_long_password(self):
         long_password = "x" * 3000
 
         creds = DatabricksCredentials(
-            host=host, token="foo", database="andre", http_path="http://foo", schema="dbt"
+            host=host,
+            token="foo",
+            database="andre",
+            http_path="http://foo",
+            schema="dbt",
         )
         creds.set_sharded_password(service, host, long_password)
 
diff --git a/tests/unit/test_compute_config.py b/tests/unit/test_compute_config.py
index 5c9d35e23..91d70b0fd 100644
--- a/tests/unit/test_compute_config.py
+++ b/tests/unit/test_compute_config.py
@@ -1,7 +1,10 @@
 import unittest
+
 import dbt.exceptions
-from dbt.contracts.graph import nodes, model_config
 from dbt.adapters.databricks import connections
+from dbt.adapters.databricks.credentials import DatabricksCredentials
+from dbt.contracts.graph import model_config
+from dbt.contracts.graph import nodes
 
 
 class TestDatabricksConnectionHTTPPath(unittest.TestCase):
@@ -13,7 +16,7 @@ class TestDatabricksConnectionHTTPPath(unittest.TestCase):
 
     def test_get_http_path_model(self):
         default_path = "my_http_path"
-        creds = connections.DatabricksCredentials(http_path=default_path)
+        creds = DatabricksCredentials(http_path=default_path)
 
         path = connections._get_http_path(None, creds)
         self.assertEqual(default_path, path)
@@ -70,7 +73,7 @@ def test_get_http_path_model(self):
 
     def test_get_http_path_seed(self):
         default_path = "my_http_path"
-        creds = connections.DatabricksCredentials(http_path=default_path)
+        creds = DatabricksCredentials(http_path=default_path)
 
         path = connections._get_http_path(None, creds)
         self.assertEqual(default_path, path)
@@ -127,7 +130,7 @@ def test_get_http_path_seed(self):
 
     def test_get_http_path_snapshot(self):
         default_path = "my_http_path"
-        creds = connections.DatabricksCredentials(http_path=default_path)
+        creds = DatabricksCredentials(http_path=default_path)
 
         path = connections._get_http_path(None, creds)
         self.assertEqual(default_path, path)
diff --git a/tests/unit/test_idle_config.py b/tests/unit/test_idle_config.py
index 62a4da408..1e317e2c6 100644
--- a/tests/unit/test_idle_config.py
+++ b/tests/unit/test_idle_config.py
@@ -1,10 +1,12 @@
-import unittest
-import dbt.exceptions
-from dbt.contracts.graph import nodes, model_config
+import pytest
 from dbt.adapters.databricks import connections
+from dbt.adapters.databricks.credentials import DatabricksCredentials
+from dbt.contracts.graph import model_config
+from dbt.contracts.graph import nodes
+from dbt_common.exceptions import DbtRuntimeError
 
 
-class TestDatabricksConnectionMaxIdleTime(unittest.TestCase):
+class TestDatabricksConnectionMaxIdleTime:
     """Test the various cases for determining a specified warehouse."""
 
     errMsg = (
@@ -12,11 +14,11 @@ class TestDatabricksConnectionMaxIdleTime(unittest.TestCase):
     )
 
     def test_get_max_idle_default(self):
-        creds = connections.DatabricksCredentials()
+        creds = DatabricksCredentials()
 
         # No node and nothing specified in creds
         time = connections._get_max_idle_time(None, creds)
-        self.assertEqual(connections.DEFAULT_MAX_IDLE_TIME, time)
+        assert connections.DEFAULT_MAX_IDLE_TIME == time
 
         node = nodes.ModelNode(
             relation_name="a_relation",
@@ -35,31 +37,31 @@ def test_get_max_idle_default(self):
 
         # node has no configuration so should get back default
         time = connections._get_max_idle_time(node, creds)
-        self.assertEqual(connections.DEFAULT_MAX_IDLE_TIME, time)
+        assert connections.DEFAULT_MAX_IDLE_TIME == time
 
         # empty configuration should return default
         node.config = model_config.ModelConfig()
         time = connections._get_max_idle_time(node, creds)
-        self.assertEqual(connections.DEFAULT_MAX_IDLE_TIME, time)
+        assert connections.DEFAULT_MAX_IDLE_TIME == time
 
         # node with no extras in configuration should return default
         node.config._extra = {}
         time = connections._get_max_idle_time(node, creds)
-        self.assertEqual(connections.DEFAULT_MAX_IDLE_TIME, time)
+        assert connections.DEFAULT_MAX_IDLE_TIME == time
 
         # node that specifies a compute with no corresponding definition should return default
         node.config._extra["databricks_compute"] = "foo"
         time = connections._get_max_idle_time(node, creds)
-        self.assertEqual(connections.DEFAULT_MAX_IDLE_TIME, time)
+        assert connections.DEFAULT_MAX_IDLE_TIME == time
 
         creds.compute = {}
         time = connections._get_max_idle_time(node, creds)
-        self.assertEqual(connections.DEFAULT_MAX_IDLE_TIME, time)
+        assert connections.DEFAULT_MAX_IDLE_TIME == time
 
         # if alternate compute doesn't specify a max time should return default
         creds.compute = {"foo": {}}
         time = connections._get_max_idle_time(node, creds)
-        self.assertEqual(connections.DEFAULT_MAX_IDLE_TIME, time)
+        assert connections.DEFAULT_MAX_IDLE_TIME == time
         # with self.assertRaisesRegex(
         #     dbt.exceptions.DbtRuntimeError,
         #     self.errMsg,
@@ -72,11 +74,11 @@ def test_get_max_idle_default(self):
 
     def test_get_max_idle_creds(self):
         creds_idle_time = 77
-        creds = connections.DatabricksCredentials(connect_max_idle=creds_idle_time)
+        creds = DatabricksCredentials(connect_max_idle=creds_idle_time)
 
         # No node so value should come from creds
         time = connections._get_max_idle_time(None, creds)
-        self.assertEqual(creds_idle_time, time)
+        assert creds_idle_time == time
 
         node = nodes.ModelNode(
             relation_name="a_relation",
@@ -95,36 +97,36 @@ def test_get_max_idle_creds(self):
 
         # node has no configuration so should get value from creds
         time = connections._get_max_idle_time(node, creds)
-        self.assertEqual(creds_idle_time, time)
+        assert creds_idle_time == time
 
         # empty configuration should get value from creds
         node.config = model_config.ModelConfig()
         time = connections._get_max_idle_time(node, creds)
-        self.assertEqual(creds_idle_time, time)
+        assert creds_idle_time == time
 
         # node with no extras in configuration should get value from creds
         node.config._extra = {}
         time = connections._get_max_idle_time(node, creds)
-        self.assertEqual(creds_idle_time, time)
+        assert creds_idle_time == time
 
         # node that specifies a compute with no corresponding definition should get value from creds
         node.config._extra["databricks_compute"] = "foo"
         time = connections._get_max_idle_time(node, creds)
-        self.assertEqual(creds_idle_time, time)
+        assert creds_idle_time == time
 
         creds.compute = {}
         time = connections._get_max_idle_time(node, creds)
-        self.assertEqual(creds_idle_time, time)
+        assert creds_idle_time == time
 
         # if alternate compute doesn't specify a max time should get value from creds
         creds.compute = {"foo": {}}
         time = connections._get_max_idle_time(node, creds)
-        self.assertEqual(creds_idle_time, time)
+        assert creds_idle_time == time
 
     def test_get_max_idle_compute(self):
         creds_idle_time = 88
         compute_idle_time = 77
-        creds = connections.DatabricksCredentials(connect_max_idle=creds_idle_time)
+        creds = DatabricksCredentials(connect_max_idle=creds_idle_time)
         creds.compute = {"foo": {"connect_max_idle": compute_idle_time}}
 
         node = nodes.SnapshotNode(
@@ -147,12 +149,12 @@ def test_get_max_idle_compute(self):
         node.config._extra = {"databricks_compute": "foo"}
 
         time = connections._get_max_idle_time(node, creds)
-        self.assertEqual(compute_idle_time, time)
+        assert compute_idle_time == time
 
     def test_get_max_idle_invalid(self):
         creds_idle_time = "foo"
         compute_idle_time = "bar"
-        creds = connections.DatabricksCredentials(connect_max_idle=creds_idle_time)
+        creds = DatabricksCredentials(connect_max_idle=creds_idle_time)
         creds.compute = {"alternate_compute": {"connect_max_idle": compute_idle_time}}
 
         node = nodes.SnapshotNode(
@@ -173,39 +175,39 @@ def test_get_max_idle_invalid(self):
 
         node.config = model_config.SnapshotConfig()
 
-        with self.assertRaisesRegex(
-            dbt.exceptions.DbtRuntimeError,
-            f"{creds_idle_time} is not a valid value for connect_max_idle. "
-            "Must be a number of seconds.",
-        ):
+        with pytest.raises(DbtRuntimeError) as info:
             connections._get_max_idle_time(node, creds)
+        assert (
+            f"{creds_idle_time} is not a valid value for connect_max_idle. "
+            "Must be a number of seconds."
+        ) in str(info.value)
 
         node.config._extra["databricks_compute"] = "alternate_compute"
-        with self.assertRaisesRegex(
-            dbt.exceptions.DbtRuntimeError,
-            f"{compute_idle_time} is not a valid value for connect_max_idle. "
-            "Must be a number of seconds.",
-        ):
+        with pytest.raises(DbtRuntimeError) as info:
             connections._get_max_idle_time(node, creds)
+        assert (
+            f"{compute_idle_time} is not a valid value for connect_max_idle. "
+            "Must be a number of seconds."
+        ) in str(info.value)
 
         creds.compute["alternate_compute"]["connect_max_idle"] = "1.2.3"
-        with self.assertRaisesRegex(
-            dbt.exceptions.DbtRuntimeError,
-            "1.2.3 is not a valid value for connect_max_idle. " "Must be a number of seconds.",
-        ):
+        with pytest.raises(DbtRuntimeError) as info:
             connections._get_max_idle_time(node, creds)
+        assert (
+            "1.2.3 is not a valid value for connect_max_idle. " "Must be a number of seconds."
+        ) in str(info.value)
 
         creds.compute["alternate_compute"]["connect_max_idle"] = "1,002.3"
-        with self.assertRaisesRegex(
-            dbt.exceptions.DbtRuntimeError,
-            "1,002.3 is not a valid value for connect_max_idle. " "Must be a number of seconds.",
-        ):
+        with pytest.raises(DbtRuntimeError) as info:
             connections._get_max_idle_time(node, creds)
+        assert (
+            "1,002.3 is not a valid value for connect_max_idle. " "Must be a number of seconds."
+        ) in str(info.value)
 
     def test_get_max_idle_simple_string_conversion(self):
         creds_idle_time = "12"
         compute_idle_time = "34"
-        creds = connections.DatabricksCredentials(connect_max_idle=creds_idle_time)
+        creds = DatabricksCredentials(connect_max_idle=creds_idle_time)
         creds.compute = {"alternate_compute": {"connect_max_idle": compute_idle_time}}
 
         node = nodes.SnapshotNode(
@@ -227,12 +229,12 @@ def test_get_max_idle_simple_string_conversion(self):
         node.config = model_config.SnapshotConfig()
 
         time = connections._get_max_idle_time(node, creds)
-        self.assertEqual(float(creds_idle_time), time)
+        assert float(creds_idle_time) == time
 
         node.config._extra["databricks_compute"] = "alternate_compute"
         time = connections._get_max_idle_time(node, creds)
-        self.assertEqual(float(compute_idle_time), time)
+        assert float(compute_idle_time) == time
 
         creds.compute["alternate_compute"]["connect_max_idle"] = "  56 "
         time = connections._get_max_idle_time(node, creds)
-        self.assertEqual(56, time)
+        assert 56 == time
diff --git a/tests/unit/test_relation.py b/tests/unit/test_relation.py
index 5a827bade..10b15691a 100644
--- a/tests/unit/test_relation.py
+++ b/tests/unit/test_relation.py
@@ -1,10 +1,11 @@
 import unittest
 
-from jinja2.runtime import Undefined
 import pytest
+from jinja2.runtime import Undefined
 
 from dbt.adapters.databricks import relation
-from dbt.adapters.databricks.relation import DatabricksRelation, DatabricksQuotePolicy
+from dbt.adapters.databricks.relation import DatabricksQuotePolicy
+from dbt.adapters.databricks.relation import DatabricksRelation
 
 
 class TestDatabricksRelation(unittest.TestCase):
@@ -183,7 +184,8 @@ def test_matches(self):
 
 class TestRelationsFunctions:
     @pytest.mark.parametrize(
-        "database, expected", [(None, True), ("hive_metastore", True), ("not_hive", False)]
+        "database, expected",
+        [(None, True), ("hive_metastore", True), ("not_hive", False)],
     )
     def test_is_hive_metastore(self, database, expected):
         assert relation.is_hive_metastore(database) is expected
diff --git a/tests/unit/test_utils.py b/tests/unit/test_utils.py
index 9beb93ef6..12f75f554 100644
--- a/tests/unit/test_utils.py
+++ b/tests/unit/test_utils.py
@@ -1,6 +1,7 @@
 import unittest
 
-from dbt.adapters.databricks.utils import redact_credentials, remove_ansi
+from dbt.adapters.databricks.utils import redact_credentials
+from dbt.adapters.databricks.utils import remove_ansi
 
 
 class TestDatabricksUtils(unittest.TestCase):
diff --git a/tests/unit/utils.py b/tests/unit/utils.py
index af06bbbe6..ccea6516e 100644
--- a/tests/unit/utils.py
+++ b/tests/unit/utils.py
@@ -1,16 +1,12 @@
-"""Unit test utility functions.
-Note that all imports should be inside the functions to avoid import/mocking
-issues.
-"""
-
-import string
 import os
+import string
 from unittest import mock
 from unittest import TestCase
 
 import agate
 import pytest
 from dbt_common.dataclass_schema import ValidationError
+
 from dbt.config.project import PartialProject
 
 
diff --git a/tox.ini b/tox.ini
index 78465be54..6f6f45cf7 100644
--- a/tox.ini
+++ b/tox.ini
@@ -68,4 +68,4 @@ passenv =
 deps =
   -r{toxinidir}/dev-requirements.txt
   -r{toxinidir}/requirements.txt
-allowlist_externals = /bin/bash
\ No newline at end of file
+allowlist_externals = /bin/bash