sqlmesh 0.209.1.dev59__tar.gz → 0.209.1.dev61__tar.gz

{sqlmesh-0.209.1.dev59 → sqlmesh-0.209.1.dev61}/.circleci/continue_config.yml

@@ -304,6 +304,8 @@ workflows:
                 - bigquery
                 - clickhouse-cloud
                 - athena
+                # todo: enable fabric when cicd catalog create/drop implemented in manage-test-db.sh
+                #- fabric
                 - gcp-postgres
           filters:
             branches:

{sqlmesh-0.209.1.dev59 → sqlmesh-0.209.1.dev61}/.circleci/install-prerequisites.sh

@@ -12,7 +12,7 @@ fi
 
 ENGINE="$1"
 
-COMMON_DEPENDENCIES="libpq-dev netcat-traditional"
+COMMON_DEPENDENCIES="libpq-dev netcat-traditional unixodbc-dev"
 ENGINE_DEPENDENCIES=""
 
 if [ "$ENGINE" == "spark" ]; then

{sqlmesh-0.209.1.dev59 → sqlmesh-0.209.1.dev61}/.github/workflows/private-repo-test.yaml

@@ -1,7 +1,7 @@
 name: Private Repo Testing
 
 on:
-  pull_request:
+  pull_request_target:
     branches:
       - main
 
@@ -20,6 +20,7 @@ jobs:
         uses: actions/checkout@v5
         with:
           fetch-depth: 0
+          ref: ${{ github.event.pull_request.head.sha || github.ref }}
       - name: Set up Python
         uses: actions/setup-python@v5
         with:

{sqlmesh-0.209.1.dev59 → sqlmesh-0.209.1.dev61}/Makefile

@@ -173,6 +173,9 @@ clickhouse-cloud-test: guard-CLICKHOUSE_CLOUD_HOST guard-CLICKHOUSE_CLOUD_USERNA
 athena-test: guard-AWS_ACCESS_KEY_ID guard-AWS_SECRET_ACCESS_KEY guard-ATHENA_S3_WAREHOUSE_LOCATION engine-athena-install
 	pytest -n auto -m "athena" --retries 3 --junitxml=test-results/junit-athena.xml
 
+fabric-test: guard-FABRIC_HOST guard-FABRIC_CLIENT_ID guard-FABRIC_CLIENT_SECRET guard-FABRIC_DATABASE engine-fabric-install
+	pytest -n auto -m "fabric" --retries 3 --junitxml=test-results/junit-fabric.xml	
+
 gcp-postgres-test: guard-GCP_POSTGRES_INSTANCE_CONNECTION_STRING guard-GCP_POSTGRES_USER guard-GCP_POSTGRES_PASSWORD guard-GCP_POSTGRES_KEYFILE_JSON engine-gcppostgres-install
 	pytest -n auto -m "gcp_postgres" --retries 3 --junitxml=test-results/junit-gcp-postgres.xml
 

{sqlmesh-0.209.1.dev59 → sqlmesh-0.209.1.dev61}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlmesh
-Version: 0.209.1.dev59
+Version: 0.209.1.dev61
 Summary: Next-generation data transformation framework
 Author-email: "TobikoData Inc." <engineering@tobikodata.com>
 License:                                  Apache License
@@ -306,6 +306,8 @@ Requires-Dist: dbt-core<2; extra == "dbt"
 Provides-Extra: dlt
 Requires-Dist: dlt; extra == "dlt"
 Provides-Extra: duckdb
+Provides-Extra: fabric
+Requires-Dist: pyodbc>=5.0.0; extra == "fabric"
 Provides-Extra: gcppostgres
 Requires-Dist: cloud-sql-python-connector[pg8000]>=1.8.0; extra == "gcppostgres"
 Provides-Extra: github

{sqlmesh-0.209.1.dev59 → sqlmesh-0.209.1.dev61}/mkdocs.yml

@@ -83,6 +83,7 @@ nav:
       - integrations/engines/clickhouse.md
       - integrations/engines/databricks.md
       - integrations/engines/duckdb.md
+      - integrations/engines/fabric.md
       - integrations/engines/motherduck.md
       - integrations/engines/mssql.md
       - integrations/engines/mysql.md

{sqlmesh-0.209.1.dev59 → sqlmesh-0.209.1.dev61}/pyproject.toml

@@ -103,6 +103,7 @@ dev = [
 dbt = ["dbt-core<2"]
 dlt = ["dlt"]
 duckdb = []
+fabric = ["pyodbc>=5.0.0"]
 gcppostgres = ["cloud-sql-python-connector[pg8000]>=1.8.0"]
 github = ["PyGithub>=2.6.0"]
 llm = ["langchain", "openai"]
@@ -253,6 +254,7 @@ markers = [
     "clickhouse_cloud: test for Clickhouse (cloud mode)",
     "databricks: test for Databricks",
     "duckdb: test for DuckDB",
+    "fabric: test for Fabric",
     "motherduck: test for MotherDuck",
     "mssql: test for MSSQL",
     "mysql: test for MySQL",

{sqlmesh-0.209.1.dev59 → sqlmesh-0.209.1.dev61}/sqlmesh/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.209.1.dev59'
-__version_tuple__ = version_tuple = (0, 209, 1, 'dev59')
+__version__ = version = '0.209.1.dev61'
+__version_tuple__ = version_tuple = (0, 209, 1, 'dev61')
 
-__commit_id__ = commit_id = 'g0224d5f87'
+__commit_id__ = commit_id = 'g2592c5c62'

{sqlmesh-0.209.1.dev59 → sqlmesh-0.209.1.dev61}/sqlmesh/core/config/__init__.py

@@ -13,6 +13,7 @@ from sqlmesh.core.config.connection import (
     ConnectionConfig as ConnectionConfig,
     DatabricksConnectionConfig as DatabricksConnectionConfig,
     DuckDBConnectionConfig as DuckDBConnectionConfig,
+    FabricConnectionConfig as FabricConnectionConfig,
     GCPPostgresConnectionConfig as GCPPostgresConnectionConfig,
     MotherDuckConnectionConfig as MotherDuckConnectionConfig,
     MSSQLConnectionConfig as MSSQLConnectionConfig,

{sqlmesh-0.209.1.dev59 → sqlmesh-0.209.1.dev61}/sqlmesh/core/config/connection.py

@@ -43,7 +43,13 @@ if t.TYPE_CHECKING:
 
 logger = logging.getLogger(__name__)
 
-RECOMMENDED_STATE_SYNC_ENGINES = {"postgres", "gcp_postgres", "mysql", "mssql", "azuresql"}
+RECOMMENDED_STATE_SYNC_ENGINES = {
+    "postgres",
+    "gcp_postgres",
+    "mysql",
+    "mssql",
+    "azuresql",
+}
 FORBIDDEN_STATE_SYNC_ENGINES = {
     # Do not support row-level operations
     "spark",
@@ -1684,6 +1690,55 @@ class AzureSQLConnectionConfig(MSSQLConnectionConfig):
         return {"catalog_support": CatalogSupport.SINGLE_CATALOG_ONLY}
 
 
+class FabricConnectionConfig(MSSQLConnectionConfig):
+    """
+    Fabric Connection Configuration.
+    Inherits most settings from MSSQLConnectionConfig and sets the type to 'fabric'.
+    It is recommended to use the 'pyodbc' driver for Fabric.
+    """
+
+    type_: t.Literal["fabric"] = Field(alias="type", default="fabric")  # type: ignore
+    DIALECT: t.ClassVar[t.Literal["fabric"]] = "fabric"  # type: ignore
+    DISPLAY_NAME: t.ClassVar[t.Literal["Fabric"]] = "Fabric"  # type: ignore
+    DISPLAY_ORDER: t.ClassVar[t.Literal[17]] = 17  # type: ignore
+    driver: t.Literal["pyodbc"] = "pyodbc"
+    workspace_id: str
+    tenant_id: str
+    autocommit: t.Optional[bool] = True
+
+    @property
+    def _engine_adapter(self) -> t.Type[EngineAdapter]:
+        from sqlmesh.core.engine_adapter.fabric import FabricEngineAdapter
+
+        return FabricEngineAdapter
+
+    @property
+    def _connection_factory(self) -> t.Callable:
+        # Override to support catalog switching for Fabric
+        base_factory = super()._connection_factory
+
+        def create_fabric_connection(
+            target_catalog: t.Optional[str] = None, *args: t.Any, **kwargs: t.Any
+        ) -> t.Callable:
+            kwargs["database"] = target_catalog or self.database
+            return base_factory(*args, **kwargs)
+
+        return create_fabric_connection
+
+    @property
+    def _extra_engine_config(self) -> t.Dict[str, t.Any]:
+        return {
+            "database": self.database,
+            # more operations than not require a specific catalog to be already active
+            # in particular, create/drop view, create/drop schema and querying information_schema
+            "catalog_support": CatalogSupport.REQUIRES_SET_CATALOG,
+            "workspace_id": self.workspace_id,
+            "tenant_id": self.tenant_id,
+            "user": self.user,
+            "password": self.password,
+        }
+
+
 class SparkConnectionConfig(ConnectionConfig):
     """
     Vanilla Spark Connection Configuration. Use `DatabricksConnectionConfig` for Databricks.

{sqlmesh-0.209.1.dev59 → sqlmesh-0.209.1.dev61}/sqlmesh/core/engine_adapter/__init__.py

@@ -19,6 +19,7 @@ from sqlmesh.core.engine_adapter.spark import SparkEngineAdapter
 from sqlmesh.core.engine_adapter.trino import TrinoEngineAdapter
 from sqlmesh.core.engine_adapter.athena import AthenaEngineAdapter
 from sqlmesh.core.engine_adapter.risingwave import RisingwaveEngineAdapter
+from sqlmesh.core.engine_adapter.fabric import FabricEngineAdapter
 
 DIALECT_TO_ENGINE_ADAPTER = {
     "hive": SparkEngineAdapter,
@@ -35,6 +36,7 @@ DIALECT_TO_ENGINE_ADAPTER = {
     "trino": TrinoEngineAdapter,
     "athena": AthenaEngineAdapter,
     "risingwave": RisingwaveEngineAdapter,
+    "fabric": FabricEngineAdapter,
 }
 
 DIALECT_ALIASES = {

sqlmesh-0.209.1.dev61/sqlmesh/core/engine_adapter/fabric.py

@@ -0,0 +1,291 @@
+from __future__ import annotations
+
+import typing as t
+import logging
+import requests
+from functools import cached_property
+from sqlglot import exp
+from tenacity import retry, stop_after_attempt, wait_exponential, retry_if_result
+from sqlmesh.core.engine_adapter.mssql import MSSQLEngineAdapter
+from sqlmesh.core.engine_adapter.shared import (
+    InsertOverwriteStrategy,
+    SourceQuery,
+)
+from sqlmesh.core.engine_adapter.base import EngineAdapter
+from sqlmesh.utils.errors import SQLMeshError
+from sqlmesh.utils.connection_pool import ConnectionPool
+
+if t.TYPE_CHECKING:
+    from sqlmesh.core._typing import TableName
+
+
+from sqlmesh.core.engine_adapter.mixins import LogicalMergeMixin
+
+logger = logging.getLogger(__name__)
+
+
+class FabricEngineAdapter(LogicalMergeMixin, MSSQLEngineAdapter):
+    """
+    Adapter for Microsoft Fabric.
+    """
+
+    DIALECT = "fabric"
+    SUPPORTS_INDEXES = False
+    SUPPORTS_TRANSACTIONS = False
+    SUPPORTS_CREATE_DROP_CATALOG = True
+    INSERT_OVERWRITE_STRATEGY = InsertOverwriteStrategy.DELETE_INSERT
+
+    def __init__(
+        self, connection_factory_or_pool: t.Union[t.Callable, t.Any], *args: t.Any, **kwargs: t.Any
+    ) -> None:
+        # Wrap connection factory to support changing the catalog dynamically at runtime
+        if not isinstance(connection_factory_or_pool, ConnectionPool):
+            original_connection_factory = connection_factory_or_pool
+
+            connection_factory_or_pool = lambda *args, **kwargs: original_connection_factory(
+                target_catalog=self._target_catalog, *args, **kwargs
+            )
+
+        super().__init__(connection_factory_or_pool, *args, **kwargs)
+
+    @property
+    def _target_catalog(self) -> t.Optional[str]:
+        return self._connection_pool.get_attribute("target_catalog")
+
+    @_target_catalog.setter
+    def _target_catalog(self, value: t.Optional[str]) -> None:
+        self._connection_pool.set_attribute("target_catalog", value)
+
+    def _insert_overwrite_by_condition(
+        self,
+        table_name: TableName,
+        source_queries: t.List[SourceQuery],
+        target_columns_to_types: t.Optional[t.Dict[str, exp.DataType]] = None,
+        where: t.Optional[exp.Condition] = None,
+        insert_overwrite_strategy_override: t.Optional[InsertOverwriteStrategy] = None,
+        **kwargs: t.Any,
+    ) -> None:
+        # Override to avoid MERGE statement which isn't fully supported in Fabric
+        return EngineAdapter._insert_overwrite_by_condition(
+            self,
+            table_name=table_name,
+            source_queries=source_queries,
+            target_columns_to_types=target_columns_to_types,
+            where=where,
+            insert_overwrite_strategy_override=InsertOverwriteStrategy.DELETE_INSERT,
+            **kwargs,
+        )
+
+    @property
+    def api_client(self) -> FabricHttpClient:
+        # the requests Session is not guaranteed to be threadsafe
+        # so we create a http client per thread on demand
+        if existing_client := self._connection_pool.get_attribute("api_client"):
+            return existing_client
+
+        tenant_id: t.Optional[str] = self._extra_config.get("tenant_id")
+        workspace_id: t.Optional[str] = self._extra_config.get("workspace_id")
+        client_id: t.Optional[str] = self._extra_config.get("user")
+        client_secret: t.Optional[str] = self._extra_config.get("password")
+
+        if not tenant_id or not client_id or not client_secret:
+            raise SQLMeshError(
+                "Service Principal authentication requires tenant_id, client_id, and client_secret "
+                "in the Fabric connection configuration"
+            )
+
+        if not workspace_id:
+            raise SQLMeshError(
+                "Fabric requires the workspace_id to be configured in the connection configuration to create / drop catalogs"
+            )
+
+        client = FabricHttpClient(
+            tenant_id=tenant_id,
+            workspace_id=workspace_id,
+            client_id=client_id,
+            client_secret=client_secret,
+        )
+
+        self._connection_pool.set_attribute("api_client", client)
+        return client
+
+    def _create_catalog(self, catalog_name: exp.Identifier) -> None:
+        """Create a catalog (warehouse) in Microsoft Fabric via REST API."""
+        warehouse_name = catalog_name.sql(dialect=self.dialect, identify=False)
+        logger.info(f"Creating Fabric warehouse: {warehouse_name}")
+
+        self.api_client.create_warehouse(warehouse_name)
+
+    def _drop_catalog(self, catalog_name: exp.Identifier) -> None:
+        """Drop a catalog (warehouse) in Microsoft Fabric via REST API."""
+        warehouse_name = catalog_name.sql(dialect=self.dialect, identify=False)
+
+        logger.info(f"Deleting Fabric warehouse: {warehouse_name}")
+        self.api_client.delete_warehouse(warehouse_name)
+
+    def set_current_catalog(self, catalog_name: str) -> None:
+        """
+        Set the current catalog for Microsoft Fabric connections.
+
+        Override to handle Fabric's stateless session limitation where USE statements
+        don't persist across queries. Instead, we close existing connections and
+        recreate them with the new catalog in the connection configuration.
+
+        Args:
+            catalog_name: The name of the catalog (warehouse) to switch to
+
+        Note:
+            Fabric doesn't support catalog switching via USE statements because each
+            statement runs as an independent session. This method works around this
+            limitation by updating the connection pool with new catalog configuration.
+
+        See:
+            https://learn.microsoft.com/en-us/fabric/data-warehouse/sql-query-editor#limitations
+        """
+        current_catalog = self.get_current_catalog()
+
+        # If already using the requested catalog, do nothing
+        if current_catalog and current_catalog == catalog_name:
+            logger.debug(f"Already using catalog '{catalog_name}', no action needed")
+            return
+
+        logger.info(f"Switching from catalog '{current_catalog}' to '{catalog_name}'")
+
+        # note: we call close() on the connection pool instead of self.close() because self.close() calls close_all()
+        # on the connection pool but we just want to close the connection for this thread
+        self._connection_pool.close()
+        self._target_catalog = catalog_name  # new connections will use this catalog
+
+        catalog_after_switch = self.get_current_catalog()
+
+        if catalog_after_switch != catalog_name:
+            # We need to raise an error if the catalog switch failed to prevent the operation that needed the catalog switch from being run against the wrong catalog
+            raise SQLMeshError(
+                f"Unable to switch catalog to {catalog_name}, catalog ended up as {catalog_after_switch}"
+            )
+
+
+class FabricHttpClient:
+    def __init__(self, tenant_id: str, workspace_id: str, client_id: str, client_secret: str):
+        self.tenant_id = tenant_id
+        self.client_id = client_id
+        self.client_secret = client_secret
+        self.workspace_id = workspace_id
+
+    def create_warehouse(self, warehouse_name: str) -> None:
+        """Create a catalog (warehouse) in Microsoft Fabric via REST API."""
+        logger.info(f"Creating Fabric warehouse: {warehouse_name}")
+
+        request_data = {
+            "displayName": warehouse_name,
+            "description": f"Warehouse created by SQLMesh: {warehouse_name}",
+        }
+
+        response = self.session.post(self._endpoint_url("warehouses"), json=request_data)
+        response.raise_for_status()
+
+        # Handle direct success (201) or async creation (202)
+        if response.status_code == 201:
+            logger.info(f"Successfully created Fabric warehouse: {warehouse_name}")
+            return
+
+        if response.status_code == 202 and (location_header := response.headers.get("location")):
+            logger.info(f"Warehouse creation initiated for: {warehouse_name}")
+            self._wait_for_completion(location_header, warehouse_name)
+            logger.info(f"Successfully created Fabric warehouse: {warehouse_name}")
+        else:
+            logger.error(f"Unexpected response from Fabric API: {response}\n{response.text}")
+            raise SQLMeshError(f"Unable to create warehouse: {response}")
+
+    def delete_warehouse(self, warehouse_name: str) -> None:
+        """Drop a catalog (warehouse) in Microsoft Fabric via REST API."""
+        logger.info(f"Deleting Fabric warehouse: {warehouse_name}")
+
+        # Get the warehouse ID by listing warehouses
+        response = self.session.get(self._endpoint_url("warehouses"))
+        response.raise_for_status()
+
+        warehouse_name_to_id = {
+            warehouse.get("displayName"): warehouse.get("id")
+            for warehouse in response.json().get("value", [])
+        }
+
+        warehouse_id = warehouse_name_to_id.get(warehouse_name, None)
+
+        if not warehouse_id:
+            logger.error(
+                f"Fabric warehouse does not exist: {warehouse_name}\n(available warehouses: {', '.join(warehouse_name_to_id)})"
+            )
+            raise SQLMeshError(
+                f"Unable to delete Fabric warehouse {warehouse_name} as it doesnt exist"
+            )
+
+        # Delete the warehouse by ID
+        response = self.session.delete(self._endpoint_url(f"warehouses/{warehouse_id}"))
+        response.raise_for_status()
+
+        logger.info(f"Successfully deleted Fabric warehouse: {warehouse_name}")
+
+    @cached_property
+    def session(self) -> requests.Session:
+        s = requests.Session()
+
+        access_token = self._get_access_token()
+        s.headers.update({"Authorization": f"Bearer {access_token}"})
+
+        return s
+
+    def _endpoint_url(self, endpoint: str) -> str:
+        if endpoint.startswith("/"):
+            endpoint = endpoint[1:]
+
+        return f"https://api.fabric.microsoft.com/v1/workspaces/{self.workspace_id}/{endpoint}"
+
+    def _get_access_token(self) -> str:
+        """Get access token using Service Principal authentication."""
+
+        # Use Azure AD OAuth2 token endpoint
+        token_url = f"https://login.microsoftonline.com/{self.tenant_id}/oauth2/v2.0/token"
+
+        data = {
+            "grant_type": "client_credentials",
+            "client_id": self.client_id,
+            "client_secret": self.client_secret,
+            "scope": "https://api.fabric.microsoft.com/.default",
+        }
+
+        response = requests.post(token_url, data=data)
+        response.raise_for_status()
+        token_data = response.json()
+        return token_data["access_token"]
+
+    def _wait_for_completion(self, location_url: str, operation_name: str) -> None:
+        """Poll the operation status until completion."""
+
+        @retry(
+            wait=wait_exponential(multiplier=1, min=1, max=30),
+            stop=stop_after_attempt(20),
+            retry=retry_if_result(lambda result: result not in ["Succeeded", "Failed"]),
+        )
+        def _poll() -> str:
+            response = self.session.get(location_url)
+            response.raise_for_status()
+
+            result = response.json()
+            status = result.get("status", "Unknown")
+
+            logger.debug(f"Operation {operation_name} status: {status}")
+
+            if status == "Failed":
+                error_msg = result.get("error", {}).get("message", "Unknown error")
+                raise SQLMeshError(f"Operation {operation_name} failed: {error_msg}")
+            elif status in ["InProgress", "Running"]:
+                logger.debug(f"Operation {operation_name} still in progress...")
+            elif status not in ["Succeeded"]:
+                logger.warning(f"Unknown status '{status}' for operation {operation_name}")
+
+            return status
+
+        final_status = _poll()
+        if final_status != "Succeeded":
+            raise SQLMeshError(f"Operation {operation_name} completed with status: {final_status}")

{sqlmesh-0.209.1.dev59 → sqlmesh-0.209.1.dev61}/sqlmesh.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlmesh
-Version: 0.209.1.dev59
+Version: 0.209.1.dev61
 Summary: Next-generation data transformation framework
 Author-email: "TobikoData Inc." <engineering@tobikodata.com>
 License:                                  Apache License
@@ -306,6 +306,8 @@ Requires-Dist: dbt-core<2; extra == "dbt"
 Provides-Extra: dlt
 Requires-Dist: dlt; extra == "dlt"
 Provides-Extra: duckdb
+Provides-Extra: fabric
+Requires-Dist: pyodbc>=5.0.0; extra == "fabric"
 Provides-Extra: gcppostgres
 Requires-Dist: cloud-sql-python-connector[pg8000]>=1.8.0; extra == "gcppostgres"
 Provides-Extra: github

{sqlmesh-0.209.1.dev59 → sqlmesh-0.209.1.dev61}/sqlmesh.egg-info/SOURCES.txt

@@ -267,6 +267,7 @@ sqlmesh/core/engine_adapter/bigquery.py
 sqlmesh/core/engine_adapter/clickhouse.py
 sqlmesh/core/engine_adapter/databricks.py
 sqlmesh/core/engine_adapter/duckdb.py
+sqlmesh/core/engine_adapter/fabric.py
 sqlmesh/core/engine_adapter/mixins.py
 sqlmesh/core/engine_adapter/mssql.py
 sqlmesh/core/engine_adapter/mysql.py
@@ -549,6 +550,7 @@ tests/core/engine_adapter/test_bigquery.py
 tests/core/engine_adapter/test_clickhouse.py
 tests/core/engine_adapter/test_databricks.py
 tests/core/engine_adapter/test_duckdb.py
+tests/core/engine_adapter/test_fabric.py
 tests/core/engine_adapter/test_mixins.py
 tests/core/engine_adapter/test_mssql.py
 tests/core/engine_adapter/test_mysql.py

{sqlmesh-0.209.1.dev59 → sqlmesh-0.209.1.dev61}/sqlmesh.egg-info/requires.txt

@@ -100,6 +100,9 @@ dlt
 
 [duckdb]
 
+[fabric]
+pyodbc>=5.0.0
+
 [gcppostgres]
 cloud-sql-python-connector[pg8000]>=1.8.0
 

{sqlmesh-0.209.1.dev59 → sqlmesh-0.209.1.dev61}/tests/conftest.py

@@ -478,7 +478,7 @@ def make_mocked_engine_adapter(mocker: MockerFixture) -> t.Callable:
         connection_mock.cursor.return_value = cursor_mock
         cursor_mock.connection.return_value = connection_mock
         adapter = klass(
-            lambda: connection_mock,
+            lambda *args, **kwargs: connection_mock,
             dialect=dialect or klass.DIALECT,
             register_comments=register_comments,
             default_catalog=default_catalog,

{sqlmesh-0.209.1.dev59 → sqlmesh-0.209.1.dev61}/tests/core/engine_adapter/integration/__init__.py

@@ -82,6 +82,7 @@ ENGINES = [
     IntegrationTestEngine("bigquery", native_dataframe_type="bigframe", cloud=True),
     IntegrationTestEngine("databricks", native_dataframe_type="pyspark", cloud=True),
     IntegrationTestEngine("snowflake", native_dataframe_type="snowpark", cloud=True),
+    IntegrationTestEngine("fabric", cloud=True),
     IntegrationTestEngine("gcp_postgres", cloud=True),
 ]
 
@@ -680,6 +681,9 @@ class TestContext:
             except Exception:
                 pass
             self.engine_adapter.cursor.connection.autocommit(False)
+        elif self.dialect == "fabric":
+            # Use the engine adapter's built-in catalog creation functionality
+            self.engine_adapter.create_catalog(catalog_name)
         elif self.dialect == "snowflake":
             self.engine_adapter.execute(f'CREATE DATABASE IF NOT EXISTS "{catalog_name}"')
         elif self.dialect == "duckdb":
@@ -696,6 +700,9 @@ class TestContext:
             return  # bigquery cannot create/drop catalogs
         if self.dialect == "databricks":
             self.engine_adapter.execute(f"DROP CATALOG IF EXISTS {catalog_name} CASCADE")
+        elif self.dialect == "fabric":
+            # Use the engine adapter's built-in catalog dropping functionality
+            self.engine_adapter.drop_catalog(catalog_name)
         else:
             self.engine_adapter.execute(f'DROP DATABASE IF EXISTS "{catalog_name}"')
 

{sqlmesh-0.209.1.dev59 → sqlmesh-0.209.1.dev61}/tests/core/engine_adapter/integration/config.yaml

@@ -186,6 +186,21 @@ gateways:
     state_connection:
       type: duckdb
 
+  inttest_fabric:
+    connection:
+      type: fabric
+      driver: pyodbc
+      host: {{ env_var("FABRIC_HOST") }}
+      user: {{ env_var("FABRIC_CLIENT_ID") }}
+      password: {{ env_var("FABRIC_CLIENT_SECRET") }}
+      database: {{ env_var("FABRIC_DATABASE") }}
+      tenant_id: {{ env_var("FABRIC_TENANT_ID") }}
+      workspace_id: {{ env_var("FABRIC_WORKSPACE_ID") }}
+      odbc_properties:
+        Authentication: ActiveDirectoryServicePrincipal
+    state_connection:
+      type: duckdb
+
   inttest_gcp_postgres:
     connection:
       type: gcp_postgres
@@ -197,5 +212,6 @@ gateways:
       enable_iam_auth: true
       check_import: false
 
+
 model_defaults:
     dialect: duckdb

{sqlmesh-0.209.1.dev59 → sqlmesh-0.209.1.dev61}/tests/core/engine_adapter/integration/test_integration.py

@@ -2499,6 +2499,7 @@ def test_dialects(ctx: TestContext):
             {
                 "default": pd.Timestamp("2020-01-01 00:00:00+00:00"),
                 "clickhouse": pd.Timestamp("2020-01-01 00:00:00"),
+                "fabric": pd.Timestamp("2020-01-01 00:00:00"),
                 "mysql": pd.Timestamp("2020-01-01 00:00:00"),
                 "spark": pd.Timestamp("2020-01-01 00:00:00"),
                 "databricks": pd.Timestamp("2020-01-01 00:00:00"),
@@ -3033,14 +3034,12 @@ def test_value_normalization(
     input_data: t.Tuple[t.Any, ...],
     expected_results: t.Tuple[str, ...],
 ) -> None:
-    if (
-        ctx.dialect == "trino"
-        and ctx.engine_adapter.current_catalog_type == "hive"
-        and column_type == exp.DataType.Type.TIMESTAMPTZ
-    ):
-        pytest.skip(
-            "Trino on Hive doesnt support creating tables with TIMESTAMP WITH TIME ZONE fields"
-        )
+    # Skip TIMESTAMPTZ tests for engines that don't support it
+    if column_type == exp.DataType.Type.TIMESTAMPTZ:
+        if ctx.dialect == "trino" and ctx.engine_adapter.current_catalog_type == "hive":
+            pytest.skip("Trino on Hive doesn't support TIMESTAMP WITH TIME ZONE fields")
+        if ctx.dialect == "fabric":
+            pytest.skip("Fabric doesn't support TIMESTAMP WITH TIME ZONE fields")
 
     if not isinstance(ctx.engine_adapter, RowDiffMixin):
         pytest.skip(
@@ -3130,7 +3129,10 @@ def test_table_diff_grain_check_single_key(ctx: TestContext):
     src_table = ctx.table("source")
     target_table = ctx.table("target")
 
-    columns_to_types = {"key1": exp.DataType.build("int"), "value": exp.DataType.build("varchar")}
+    columns_to_types = {
+        "key1": exp.DataType.build("int"),
+        "value": exp.DataType.build("varchar"),
+    }
 
     ctx.engine_adapter.create_table(src_table, columns_to_types)
     ctx.engine_adapter.create_table(target_table, columns_to_types)