sqlmesh 0.220.2.dev5__tar.gz → 0.221.1__tar.gz

{sqlmesh-0.220.2.dev5 → sqlmesh-0.221.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlmesh
-Version: 0.220.2.dev5
+Version: 0.221.1
 Summary: Next-generation data transformation framework
 Author-email: "TobikoData Inc." <engineering@tobikodata.com>
 License:                                  Apache License
@@ -235,7 +235,7 @@ Requires-Dist: python-dotenv
 Requires-Dist: requests
 Requires-Dist: rich[jupyter]
 Requires-Dist: ruamel.yaml
-Requires-Dist: sqlglot[rs]~=27.15.3
+Requires-Dist: sqlglot[rs]~=27.16.3
 Requires-Dist: tenacity
 Requires-Dist: time-machine
 Requires-Dist: json-stream

{sqlmesh-0.220.2.dev5 → sqlmesh-0.221.1}/pyproject.toml

@@ -24,7 +24,7 @@ dependencies = [
     "requests",
     "rich[jupyter]",
     "ruamel.yaml",
-    "sqlglot[rs]~=27.15.3",
+    "sqlglot[rs]~=27.16.3",
     "tenacity",
     "time-machine",
     "json-stream"

{sqlmesh-0.220.2.dev5 → sqlmesh-0.221.1}/sqlmesh/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.220.2.dev5'
-__version_tuple__ = version_tuple = (0, 220, 2, 'dev5')
+__version__ = version = '0.221.1'
+__version_tuple__ = version_tuple = (0, 221, 1)
 
-__commit_id__ = commit_id = 'g54e6b5771'
+__commit_id__ = commit_id = 'g50aee2cc8'

{sqlmesh-0.220.2.dev5 → sqlmesh-0.221.1}/sqlmesh/core/model/definition.py

@@ -2866,6 +2866,13 @@ def render_meta_fields(
             for key, value in field_value.items():
                 if key in RUNTIME_RENDERED_MODEL_FIELDS:
                     rendered_dict[key] = parse_strings_with_macro_refs(value, dialect)
+                elif (
+                    # don't parse kind auto_restatement_cron="@..." kwargs (e.g. @daily) into MacroVar
+                    key == "auto_restatement_cron"
+                    and isinstance(value, str)
+                    and value.lower() in CRON_SHORTCUTS
+                ):
+                    rendered_dict[key] = value
                 elif (rendered := render_field_value(value)) is not None:
                     rendered_dict[key] = rendered
 

{sqlmesh-0.220.2.dev5 → sqlmesh-0.221.1}/sqlmesh/core/snapshot/definition.py

@@ -1480,7 +1480,7 @@ class Snapshot(PydanticModel, SnapshotInfoMixin):
     @property
     def supports_schema_migration_in_prod(self) -> bool:
         """Returns whether or not this snapshot supports schema migration when deployed to production."""
-        return self.is_paused and self.is_model and not self.is_symbolic
+        return self.is_paused and self.is_model and not self.is_symbolic and not self.is_seed
 
     @property
     def requires_schema_migration_in_prod(self) -> bool:

{sqlmesh-0.220.2.dev5 → sqlmesh-0.221.1}/sqlmesh/core/snapshot/evaluator.py

@@ -494,7 +494,7 @@ class SnapshotEvaluator:
         with self.concurrent_context():
             # Only migrate snapshots for which there's an existing data object
             concurrent_apply_to_snapshots(
-                snapshots_by_name.values(),
+                target_snapshots,
                 lambda s: self._migrate_snapshot(
                     s,
                     snapshots_by_name,
@@ -763,7 +763,7 @@ class SnapshotEvaluator:
                         snapshots=snapshots,
                         deployability_index=deployability_index,
                         render_kwargs=create_render_kwargs,
-                        rendered_physical_properties=rendered_physical_properties,
+                        rendered_physical_properties=rendered_physical_properties.copy(),
                         allow_destructive_snapshots=allow_destructive_snapshots,
                         allow_additive_snapshots=allow_additive_snapshots,
                     )
@@ -776,7 +776,7 @@ class SnapshotEvaluator:
                         is_table_deployable=is_snapshot_deployable,
                         deployability_index=deployability_index,
                         create_render_kwargs=create_render_kwargs,
-                        rendered_physical_properties=rendered_physical_properties,
+                        rendered_physical_properties=rendered_physical_properties.copy(),
                         dry_run=False,
                         run_pre_post_statements=False,
                     )
@@ -867,6 +867,7 @@ class SnapshotEvaluator:
                     rendered_physical_properties=rendered_physical_properties,
                     allow_destructive_snapshots=allow_destructive_snapshots,
                     allow_additive_snapshots=allow_additive_snapshots,
+                    run_pre_post_statements=True,
                 )
             else:
                 is_table_deployable = deployability_index.is_deployable(snapshot)
@@ -1026,6 +1027,7 @@ class SnapshotEvaluator:
         rendered_physical_properties: t.Dict[str, exp.Expression],
         allow_destructive_snapshots: t.Set[str],
         allow_additive_snapshots: t.Set[str],
+        run_pre_post_statements: bool = False,
     ) -> None:
         adapter = self.get_adapter(snapshot.model.gateway)
 
@@ -1048,6 +1050,7 @@ class SnapshotEvaluator:
                 rendered_physical_properties=rendered_physical_properties,
                 allow_destructive_snapshots=allow_destructive_snapshots,
                 allow_additive_snapshots=allow_additive_snapshots,
+                run_pre_post_statements=run_pre_post_statements,
             )
         except Exception:
             adapter.drop_table(target_table_name)

{sqlmesh-0.220.2.dev5 → sqlmesh-0.221.1}/sqlmesh/dbt/adapter.py

@@ -115,28 +115,32 @@ class BaseAdapter(abc.ABC):
         """Returns the value quoted according to the quote policy."""
         return self.quote(value) if getattr(self.quote_policy, component_type, False) else value
 
-    def dispatch(self, name: str, package: t.Optional[str] = None) -> t.Callable:
+    def dispatch(
+        self,
+        macro_name: str,
+        macro_namespace: t.Optional[str] = None,
+    ) -> t.Callable:
         """Returns a dialect-specific version of a macro with the given name."""
         target_type = self.jinja_globals["target"]["type"]
-        macro_suffix = f"__{name}"
+        macro_suffix = f"__{macro_name}"
 
         def _relevance(package_name_pair: t.Tuple[t.Optional[str], str]) -> t.Tuple[int, int]:
             """Lower scores more relevant."""
-            macro_package, macro_name = package_name_pair
+            macro_package, name = package_name_pair
 
-            package_score = 0 if macro_package == package else 1
+            package_score = 0 if macro_package == macro_namespace else 1
             name_score = 1
 
-            if macro_name.startswith("default"):
+            if name.startswith("default"):
                 name_score = 2
-            elif macro_name.startswith(target_type):
+            elif name.startswith(target_type):
                 name_score = 0
 
             return name_score, package_score
 
         jinja_env = self.jinja_macros.build_environment(**self.jinja_globals).globals
         packages_to_check: t.List[t.Optional[str]] = [
-            package,
+            macro_namespace,
             *(k for k in jinja_env if k.startswith("dbt")),
         ]
         candidates = {}
@@ -156,7 +160,7 @@ class BaseAdapter(abc.ABC):
             sorted_candidates = sorted(candidates, key=_relevance)
             return candidates[sorted_candidates[0]]
 
-        raise ConfigError(f"Macro '{name}', package '{package}' was not found.")
+        raise ConfigError(f"Macro '{macro_name}', package '{macro_namespace}' was not found.")
 
     def type(self) -> str:
         return self.project_dialect or ""

{sqlmesh-0.220.2.dev5 → sqlmesh-0.221.1}/sqlmesh/dbt/model.py

@@ -539,10 +539,11 @@ class ModelConfig(BaseModelConfig):
                     optional_kwargs["partitioned_by"] = partitioned_by
 
         if self.cluster_by:
-            if isinstance(kind, ViewKind):
+            if isinstance(kind, (ViewKind, EmbeddedKind)):
                 logger.warning(
-                    "Ignoring cluster_by config for model '%s'; cluster_by is not supported for views.",
+                    "Ignoring cluster_by config for model '%s'; cluster_by is not supported for %s.",
                     self.name,
+                    "views" if isinstance(kind, ViewKind) else "ephemeral models",
                 )
             else:
                 clustered_by = []

{sqlmesh-0.220.2.dev5 → sqlmesh-0.221.1}/sqlmesh.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlmesh
-Version: 0.220.2.dev5
+Version: 0.221.1
 Summary: Next-generation data transformation framework
 Author-email: "TobikoData Inc." <engineering@tobikodata.com>
 License:                                  Apache License
@@ -235,7 +235,7 @@ Requires-Dist: python-dotenv
 Requires-Dist: requests
 Requires-Dist: rich[jupyter]
 Requires-Dist: ruamel.yaml
-Requires-Dist: sqlglot[rs]~=27.15.3
+Requires-Dist: sqlglot[rs]~=27.16.3
 Requires-Dist: tenacity
 Requires-Dist: time-machine
 Requires-Dist: json-stream

{sqlmesh-0.220.2.dev5 → sqlmesh-0.221.1}/sqlmesh.egg-info/requires.txt

@@ -14,7 +14,7 @@ python-dotenv
 requests
 rich[jupyter]
 ruamel.yaml
-sqlglot[rs]~=27.15.3
+sqlglot[rs]~=27.16.3
 tenacity
 time-machine
 json-stream

{sqlmesh-0.220.2.dev5 → sqlmesh-0.221.1}/tests/core/test_integration.py

@@ -14,7 +14,13 @@ import pandas as pd  # noqa: TID253
 import pytest
 from pytest import MonkeyPatch
 from pathlib import Path
-from sqlmesh.core.console import set_console, get_console, TerminalConsole, CaptureTerminalConsole
+from sqlmesh.core.console import (
+    MarkdownConsole,
+    set_console,
+    get_console,
+    TerminalConsole,
+    CaptureTerminalConsole,
+)
 from sqlmesh.core.config.naming import NameInferenceConfig
 from sqlmesh.core.model.common import ParsableSql
 from sqlmesh.utils.concurrency import NodeExecutionFailedError
@@ -1672,6 +1678,42 @@ def test_run_with_select_models(
         }
 
 
+@time_machine.travel("2023-01-08 15:00:00 UTC")
+def test_seed_model_promote_to_prod_after_dev(
+    init_and_plan_context: t.Callable,
+):
+    context, plan = init_and_plan_context("examples/sushi")
+    context.apply(plan)
+
+    with open(context.path / "seeds" / "waiter_names.csv", "a") as f:
+        f.write("\n10,New Waiter")
+
+    context.load()
+
+    waiter_names_snapshot = context.get_snapshot("sushi.waiter_names")
+    plan = context.plan("dev", skip_tests=True, auto_apply=True, no_prompts=True)
+    assert waiter_names_snapshot.snapshot_id in plan.directly_modified
+
+    # Trigger a metadata change to reuse the previous version
+    waiter_names_model = waiter_names_snapshot.model.copy(
+        update={"description": "Updated description"}
+    )
+    context.upsert_model(waiter_names_model)
+    context.plan("dev", skip_tests=True, auto_apply=True, no_prompts=True)
+
+    # Promote all changes to prod
+    waiter_names_snapshot = context.get_snapshot("sushi.waiter_names")
+    plan = context.plan_builder("prod", skip_tests=True).build()
+    # Clear the cache to source the dehydrated model instance from the state
+    context.clear_caches()
+    context.apply(plan)
+
+    assert (
+        context.engine_adapter.fetchone("SELECT COUNT(*) FROM sushi.waiter_names WHERE id = 10")[0]
+        == 1
+    )
+
+
 @time_machine.travel("2023-01-08 15:00:00 UTC")
 def test_plan_with_run(
     init_and_plan_context: t.Callable,
@@ -10589,9 +10631,16 @@ def entrypoint(evaluator: MacroEvaluator) -> str:
     new_model_a_snapshot_id = list(plan.modified_snapshots)[0]
 
     # now, trigger a prod restatement plan in a different thread and block it to simulate a long restatement
+    thread_console = None
+
     def _run_restatement_plan(tmp_path: Path, config: Config, q: queue.Queue):
+        nonlocal thread_console
         q.put("thread_started")
 
+        # Give this thread its own markdown console to avoid Rich LiveError
+        thread_console = MarkdownConsole()
+        set_console(thread_console)
+
         # give this thread its own Context object to prevent segfaulting the Python interpreter
         restatement_ctx = Context(paths=[tmp_path], config=config)
 
@@ -10647,7 +10696,7 @@ def entrypoint(evaluator: MacroEvaluator) -> str:
     assert isinstance(plan_error, ConflictingPlanError)
     assert "please re-apply your plan" in repr(plan_error).lower()
 
-    output = " ".join(re.split("\s+", console.captured_output, flags=re.UNICODE))
+    output = " ".join(re.split("\\s+", thread_console.captured_output, flags=re.UNICODE))  # type: ignore
     assert (
         f"The following models had new versions deployed while data was being restated: └── test.model_a"
         in output

{sqlmesh-0.220.2.dev5 → sqlmesh-0.221.1}/tests/core/test_model.py

@@ -2898,7 +2898,15 @@ def test_python_model_decorator_kind() -> None:
     # no warning with valid kind dict
     with patch.object(get_console(), "log_warning") as mock_logger:
 
-        @model("kind_valid_dict", kind=dict(name=ModelKindName.FULL), columns={'"COL"': "int"})
+        @model(
+            "kind_valid_dict",
+            kind=dict(
+                name=ModelKindName.INCREMENTAL_BY_TIME_RANGE,
+                time_column="ds",
+                auto_restatement_cron="@hourly",
+            ),
+            columns={'"ds"': "date", '"COL"': "int"},
+        )
         def my_model(context):
             pass
 
@@ -2907,11 +2915,33 @@ def test_python_model_decorator_kind() -> None:
             path=Path("."),
         )
 
-        assert isinstance(python_model.kind, FullKind)
+        assert isinstance(python_model.kind, IncrementalByTimeRangeKind)
 
         assert not mock_logger.call_args
 
 
+def test_python_model_decorator_auto_restatement_cron() -> None:
+    @model(
+        "auto_restatement_model",
+        cron="@daily",
+        kind=dict(
+            name=ModelKindName.INCREMENTAL_BY_TIME_RANGE,
+            time_column="ds",
+            auto_restatement_cron="@hourly",
+        ),
+        columns={'"ds"': "date", '"COL"': "int"},
+    )
+    def my_model(context):
+        pass
+
+    python_model = model.get_registry()["auto_restatement_model"].model(
+        module_path=Path("."),
+        path=Path("."),
+    )
+
+    assert python_model.auto_restatement_cron == "@hourly"
+
+
 def test_python_model_decorator_col_descriptions() -> None:
     # `columns` and `column_descriptions` column names are different cases, but name normalization makes both lower
     @model("col_descriptions", columns={"col": "int"}, column_descriptions={"COL": "a column"})

{sqlmesh-0.220.2.dev5 → sqlmesh-0.221.1}/tests/core/test_snapshot_evaluator.py

@@ -854,6 +854,55 @@ def test_create_prod_table_exists(mocker: MockerFixture, adapter_mock, make_snap
     )
 
 
+def test_pre_hook_forward_only_clone(
+    mocker: MockerFixture, make_mocked_engine_adapter, make_snapshot
+):
+    """
+    Verifies that pre-statements are executed when creating a clone of a forward-only model.
+    """
+    pre_statement = """CREATE TEMPORARY FUNCTION "example_udf"("x" BIGINT) AS ("x" + 1)"""
+    model = load_sql_based_model(
+        parse(  # type: ignore
+            f"""
+            MODEL (
+                name test_schema.test_model,
+                kind INCREMENTAL_BY_TIME_RANGE (
+                    time_column ds
+                )
+            );
+            
+            {pre_statement};
+
+            SELECT a::int, ds::string FROM tbl;
+            """
+        ),
+    )
+
+    snapshot = make_snapshot(model)
+    snapshot.categorize_as(SnapshotChangeCategory.BREAKING, forward_only=True)
+    snapshot.previous_versions = snapshot.all_versions
+
+    adapter = make_mocked_engine_adapter(EngineAdapter)
+    adapter.with_settings = lambda **kwargs: adapter
+    adapter.table_exists = lambda _: True  # type: ignore
+    adapter.SUPPORTS_CLONING = True
+    mocker.patch.object(
+        adapter,
+        "get_data_objects",
+        return_value=[],
+    )
+    mocker.patch.object(
+        adapter,
+        "get_alter_operations",
+        return_value=[],
+    )
+
+    evaluator = SnapshotEvaluator(adapter)
+
+    evaluator.create([snapshot], {}, deployability_index=DeployabilityIndex.none_deployable())
+    adapter.cursor.execute.assert_any_call(pre_statement)
+
+
 def test_create_only_dev_table_exists(mocker: MockerFixture, adapter_mock, make_snapshot):
     model = load_sql_based_model(
         parse(  # type: ignore
@@ -3906,6 +3955,63 @@ def test_migrate_snapshot(snapshot: Snapshot, mocker: MockerFixture, adapter_moc
     )
 
 
+def test_migrate_only_processes_target_snapshots(
+    mocker: MockerFixture, adapter_mock, make_snapshot
+):
+    evaluator = SnapshotEvaluator(adapter_mock)
+
+    target_model = SqlModel(
+        name="test_schema.target_model",
+        kind=FullKind(),
+        query=parse_one("SELECT 1 AS a"),
+    )
+    extra_model = SqlModel(
+        name="test_schema.extra_model",
+        kind=FullKind(),
+        query=parse_one("SELECT 1 AS a"),
+    )
+
+    target_snapshot = make_snapshot(target_model)
+    extra_snapshot = make_snapshot(extra_model)
+    target_snapshot.categorize_as(SnapshotChangeCategory.BREAKING)
+    extra_snapshot.categorize_as(SnapshotChangeCategory.BREAKING)
+
+    target_snapshots = [target_snapshot]
+    snapshots = {
+        target_snapshot.snapshot_id: target_snapshot,
+        extra_snapshot.snapshot_id: extra_snapshot,
+    }
+
+    mocker.patch.object(
+        evaluator,
+        "_get_data_objects",
+        return_value={target_snapshot.snapshot_id: mocker.Mock()},
+    )
+    migrate_mock = mocker.patch.object(evaluator, "_migrate_snapshot")
+
+    def apply_side_effect(snapshot_iterable, fn, *_args, **_kwargs):
+        for snapshot in snapshot_iterable:
+            fn(snapshot)
+        return ([], [])
+
+    apply_mock = mocker.patch(
+        "sqlmesh.core.snapshot.evaluator.concurrent_apply_to_snapshots",
+        side_effect=apply_side_effect,
+    )
+
+    evaluator.migrate(target_snapshots=target_snapshots, snapshots=snapshots)
+
+    assert apply_mock.call_count == 1
+    called_snapshots = list(apply_mock.call_args.args[0])
+    assert called_snapshots == target_snapshots
+
+    migrate_mock.assert_called_once()
+    called_snapshot, snapshots_by_name, *_ = migrate_mock.call_args.args
+    assert called_snapshot is target_snapshot
+    assert target_snapshot.name in snapshots_by_name
+    assert extra_snapshot.name in snapshots_by_name
+
+
 def test_migrate_managed(adapter_mock, make_snapshot, mocker: MockerFixture):
     evaluator = SnapshotEvaluator(adapter_mock)
 
@@ -4631,3 +4737,79 @@ def test_wap_publish_failure(adapter_mock: Mock, make_snapshot: t.Callable[...,
     # Execute audit with WAP ID and expect it to raise the exception
     with pytest.raises(Exception, match="WAP publish failed"):
         evaluator.audit(snapshot, snapshots={}, wap_id=wap_id)
+
+
+def test_properties_are_preserved_in_both_create_statements(
+    adapter_mock: Mock, make_snapshot: t.Callable[..., Snapshot]
+) -> None:
+    # the below mocks are needed to create a situation
+    # where we trigger two create statements during evaluation
+    transaction_mock = Mock()
+    transaction_mock.__enter__ = Mock()
+    transaction_mock.__exit__ = Mock()
+    session_mock = Mock()
+    session_mock.__enter__ = Mock()
+    session_mock.__exit__ = Mock()
+    adapter_mock = Mock()
+    adapter_mock.transaction.return_value = transaction_mock
+    adapter_mock.session.return_value = session_mock
+    adapter_mock.dialect = "trino"
+    adapter_mock.HAS_VIEW_BINDING = False
+    adapter_mock.wap_supported.return_value = False
+    adapter_mock.get_data_objects.return_value = []
+    adapter_mock.with_settings.return_value = adapter_mock
+    adapter_mock.table_exists.return_value = False
+
+    props = []
+
+    def mutate_view_properties(*args, **kwargs):
+        view_props = kwargs.get("view_properties")
+        if isinstance(view_props, dict):
+            props.append(view_props["creatable_type"].sql())
+            # simulate view pop
+            view_props.pop("creatable_type")
+        return None
+
+    adapter_mock.create_view.side_effect = mutate_view_properties
+
+    evaluator = SnapshotEvaluator(adapter_mock)
+
+    # create a view model with SECURITY INVOKER physical property
+    # AND self referenctial to trigger two create statements
+    model = load_sql_based_model(
+        parse(  # type: ignore
+            """
+            MODEL (
+                name test_schema.security_view,
+                kind VIEW,
+                physical_properties (
+                    'creatable_type' = 'SECURITY INVOKER'
+                )
+            );
+
+            SELECT 1 as col from test_schema.security_view;
+            """
+        ),
+    )
+
+    snapshot = make_snapshot(model)
+    snapshot.categorize_as(SnapshotChangeCategory.BREAKING)
+    evaluator.evaluate(
+        snapshot,
+        start="2024-01-01",
+        end="2024-01-02",
+        execution_time="2024-01-02",
+        snapshots={},
+    )
+
+    # Verify create_view was called twice
+    assert adapter_mock.create_view.call_count == 2
+    first_call = adapter_mock.create_view.call_args_list[0]
+    second_call = adapter_mock.create_view.call_args_list[1]
+
+    # First call should be CREATE VIEW (replace=False) second CREATE OR REPLACE VIEW (replace=True)
+    assert first_call.kwargs.get("replace") == False
+    assert second_call.kwargs.get("replace") == True
+
+    # Both calls should have view_properties with security invoker
+    assert props == ["'SECURITY INVOKER'", "'SECURITY INVOKER'"]

{sqlmesh-0.220.2.dev5 → sqlmesh-0.221.1}/tests/dbt/test_adapter.py

@@ -243,6 +243,34 @@ def test_adapter_dispatch(sushi_test_project: Project, runtime_renderer: t.Calla
     assert renderer("{{ adapter.dispatch('current_timestamp')() }}") == "now()"
     assert renderer("{{ adapter.dispatch('current_timestamp', 'dbt')() }}") == "now()"
 
+    # test with keyword arguments
+    assert (
+        renderer(
+            "{{ adapter.dispatch(macro_name='current_engine', macro_namespace='customers')() }}"
+        )
+        == "duckdb"
+    )
+    assert renderer("{{ adapter.dispatch(macro_name='current_timestamp')() }}") == "now()"
+    assert (
+        renderer("{{ adapter.dispatch(macro_name='current_timestamp', macro_namespace='dbt')() }}")
+        == "now()"
+    )
+
+    # mixing positional and keyword arguments
+    assert (
+        renderer("{{ adapter.dispatch('current_engine', macro_namespace='customers')() }}")
+        == "duckdb"
+    )
+    assert (
+        renderer("{{ adapter.dispatch('current_timestamp', macro_namespace=None)() }}") == "now()"
+    )
+    assert (
+        renderer("{{ adapter.dispatch('current_timestamp', macro_namespace='dbt')() }}") == "now()"
+    )
+
+    with pytest.raises(ConfigError, match=r"Macro 'current_engine'.*was not found."):
+        renderer("{{ adapter.dispatch(macro_name='current_engine')() }}")
+
     with pytest.raises(ConfigError, match=r"Macro 'current_engine'.*was not found."):
         renderer("{{ adapter.dispatch('current_engine')() }}")
 

{sqlmesh-0.220.2.dev5 → sqlmesh-0.221.1}/tests/dbt/test_transformation.py

@@ -2074,6 +2074,17 @@ def test_model_cluster_by():
     )
     assert model.to_sqlmesh(context).clustered_by == []
 
+    model = ModelConfig(
+        name="model",
+        alias="model",
+        package_name="package",
+        target_schema="test",
+        cluster_by=["Bar", "qux"],
+        sql="SELECT * FROM baz",
+        materialized=Materialization.EPHEMERAL.value,
+    )
+    assert model.to_sqlmesh(context).clustered_by == []
+
 
 def test_snowflake_dynamic_table():
     context = DbtContext()