sqlmesh 0.208.2.dev1__tar.gz → 0.208.2.dev3__tar.gz

{sqlmesh-0.208.2.dev1 → sqlmesh-0.208.2.dev3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlmesh
-Version: 0.208.2.dev1
+Version: 0.208.2.dev3
 Summary: Next-generation data transformation framework
 Author-email: "TobikoData Inc." <engineering@tobikodata.com>
 License:                                  Apache License

{sqlmesh-0.208.2.dev1 → sqlmesh-0.208.2.dev3}/sqlmesh/_version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.208.2.dev1'
-__version_tuple__ = version_tuple = (0, 208, 2, 'dev1')
+__version__ = version = '0.208.2.dev3'
+__version_tuple__ = version_tuple = (0, 208, 2, 'dev3')

{sqlmesh-0.208.2.dev1 → sqlmesh-0.208.2.dev3}/sqlmesh/core/context.py

@@ -2537,8 +2537,8 @@ class GenericContext(BaseContext, t.Generic[C]):
         if self.cache_dir.exists():
             rmtree(self.cache_dir)
 
-        if isinstance(self.state_sync, CachingStateSync):
-            self.state_sync.clear_cache()
+        if isinstance(self._state_sync, CachingStateSync):
+            self._state_sync.clear_cache()
 
     def export_state(
         self,

{sqlmesh-0.208.2.dev1 → sqlmesh-0.208.2.dev3}/sqlmesh/core/plan/builder.py

@@ -239,8 +239,6 @@ class PlanBuilder:
             snapshot: The target snapshot.
             choice: The user decision on how to version the target snapshot and its children.
         """
-        if self._forward_only:
-            raise PlanError("Choice setting is not supported by a forward-only plan.")
         if not self._is_new_snapshot(snapshot):
             raise PlanError(
                 f"A choice can't be changed for the existing version of {snapshot.name}."
@@ -250,8 +248,6 @@ class PlanBuilder:
             and snapshot.snapshot_id not in self._context_diff.added
         ):
             raise PlanError(f"Only directly modified models can be categorized ({snapshot.name}).")
-        if snapshot.is_model and snapshot.model.forward_only:
-            raise PlanError(f"Forward-only model {snapshot.name} cannot be categorized manually.")
 
         self._choices[snapshot.snapshot_id] = choice
         self._latest_plan = None
@@ -369,8 +365,10 @@ class PlanBuilder:
             restate_models = {
                 s.name
                 for s in self._context_diff.new_snapshots.values()
-                if s.is_materialized
-                and (self._forward_only or s.model.forward_only)
+                if s.is_model
+                and not s.is_symbolic
+                and (s.is_forward_only or s.model.forward_only)
+                and not s.is_no_preview
                 and (
                     # Metadata changes should not be previewed.
                     self._context_diff.directly_modified(s.name)
@@ -395,6 +393,9 @@ class PlanBuilder:
         for s_id in dag:
             snapshot = self._context_diff.snapshots[s_id]
 
+            if is_preview and snapshot.is_no_preview:
+                continue
+
             # Since we are traversing the graph in topological order and the largest interval range is pushed down
             # the graph we just have to check our immediate parents in the graph and not the whole upstream graph.
             restating_parents = [
@@ -526,6 +527,9 @@ class PlanBuilder:
 
     def _check_destructive_changes(self, directly_modified: t.Set[SnapshotId]) -> None:
         for s_id in sorted(directly_modified):
+            if s_id.name not in self._context_diff.modified_snapshots:
+                continue
+
             snapshot = self._context_diff.snapshots[s_id]
             # should we raise/warn if this snapshot has/inherits a destructive change?
             should_raise_or_warn = (
@@ -583,38 +587,38 @@ class PlanBuilder:
             if not snapshot or not self._is_new_snapshot(snapshot):
                 continue
 
+            forward_only = self._is_forward_only_change(s_id) or self._forward_only
+
             if s_id in self._choices:
-                snapshot.categorize_as(self._choices[s_id])
+                snapshot.categorize_as(self._choices[s_id], forward_only)
                 continue
 
             if s_id in self._context_diff.added:
-                snapshot.categorize_as(SnapshotChangeCategory.BREAKING)
-            elif self._is_forward_only_change(s_id) or self._forward_only:
-                # In case of the forward only plan any modifications result in reuse of the
-                # previous version for non-seed models.
-                # New snapshots of seed models are considered non-breaking ones.
-                category = (
-                    SnapshotChangeCategory.NON_BREAKING
-                    if snapshot.is_seed
-                    else SnapshotChangeCategory.FORWARD_ONLY
-                )
-                # If the model kind changes mark as breaking
-                if snapshot.is_model and snapshot.name in self._context_diff.modified_snapshots:
-                    _, old = self._context_diff.modified_snapshots[snapshot.name]
-                    if _is_breaking_kind_change(old, snapshot):
-                        category = SnapshotChangeCategory.BREAKING
-
-                snapshot.categorize_as(category)
+                snapshot.categorize_as(SnapshotChangeCategory.BREAKING, forward_only)
             elif s_id.name in self._context_diff.modified_snapshots:
-                self._categorize_snapshot(snapshot, dag, indirectly_modified)
+                self._categorize_snapshot(snapshot, forward_only, dag, indirectly_modified)
 
     def _categorize_snapshot(
-        self, snapshot: Snapshot, dag: DAG[SnapshotId], indirectly_modified: SnapshotMapping
+        self,
+        snapshot: Snapshot,
+        forward_only: bool,
+        dag: DAG[SnapshotId],
+        indirectly_modified: SnapshotMapping,
     ) -> None:
         s_id = snapshot.snapshot_id
 
         if self._context_diff.directly_modified(s_id.name):
+            new, old = self._context_diff.modified_snapshots[s_id.name]
+            is_breaking_kind_change = _is_breaking_kind_change(old, new)
+            if is_breaking_kind_change or snapshot.is_seed:
+                # Breaking kind changes and seed changes can't be forward-only.
+                forward_only = False
+
             if self._auto_categorization_enabled:
+                if is_breaking_kind_change:
+                    snapshot.categorize_as(SnapshotChangeCategory.BREAKING, forward_only)
+                    return
+
                 s_id_with_missing_columns: t.Optional[SnapshotId] = None
                 this_sid_with_downstream = indirectly_modified.get(s_id, set()) | {s_id}
                 for downstream_s_id in this_sid_with_downstream:
@@ -626,18 +630,18 @@ class PlanBuilder:
                         s_id_with_missing_columns = downstream_s_id
                         break
 
-                new, old = self._context_diff.modified_snapshots[s_id.name]
                 if s_id_with_missing_columns is None:
                     change_category = categorize_change(new, old, config=self._categorizer_config)
                     if change_category is not None:
-                        snapshot.categorize_as(change_category)
+                        snapshot.categorize_as(change_category, forward_only)
                 else:
                     mode = self._categorizer_config.dict().get(
                         new.model.source_type, AutoCategorizationMode.OFF
                     )
                     if mode == AutoCategorizationMode.FULL:
-                        snapshot.categorize_as(SnapshotChangeCategory.BREAKING)
+                        snapshot.categorize_as(SnapshotChangeCategory.BREAKING, forward_only)
         elif self._context_diff.indirectly_modified(snapshot.name):
+            all_upstream_forward_only = set()
             all_upstream_categories = set()
             direct_parent_categories = set()
 
@@ -646,27 +650,30 @@ class PlanBuilder:
 
                 if parent and self._is_new_snapshot(parent):
                     all_upstream_categories.add(parent.change_category)
+                    all_upstream_forward_only.add(parent.is_forward_only)
                     if p_id in snapshot.parents:
                         direct_parent_categories.add(parent.change_category)
 
-            if snapshot.is_model and snapshot.model.forward_only:
-                snapshot.categorize_as(SnapshotChangeCategory.FORWARD_ONLY)
-            elif direct_parent_categories.intersection(
+            if all_upstream_forward_only == {True} or (
+                snapshot.is_model and snapshot.model.forward_only
+            ):
+                forward_only = True
+
+            if direct_parent_categories.intersection(
                 {SnapshotChangeCategory.BREAKING, SnapshotChangeCategory.INDIRECT_BREAKING}
             ):
-                snapshot.categorize_as(SnapshotChangeCategory.INDIRECT_BREAKING)
+                snapshot.categorize_as(SnapshotChangeCategory.INDIRECT_BREAKING, forward_only)
             elif not direct_parent_categories:
-                snapshot.categorize_as(self._get_orphaned_indirect_change_category(snapshot))
-            elif SnapshotChangeCategory.FORWARD_ONLY in all_upstream_categories:
-                # FORWARD_ONLY must take precedence over INDIRECT_NON_BREAKING
-                snapshot.categorize_as(SnapshotChangeCategory.FORWARD_ONLY)
+                snapshot.categorize_as(
+                    self._get_orphaned_indirect_change_category(snapshot), forward_only
+                )
             elif all_upstream_categories == {SnapshotChangeCategory.METADATA}:
-                snapshot.categorize_as(SnapshotChangeCategory.METADATA)
+                snapshot.categorize_as(SnapshotChangeCategory.METADATA, forward_only)
             else:
-                snapshot.categorize_as(SnapshotChangeCategory.INDIRECT_NON_BREAKING)
+                snapshot.categorize_as(SnapshotChangeCategory.INDIRECT_NON_BREAKING, forward_only)
         else:
             # Metadata updated.
-            snapshot.categorize_as(SnapshotChangeCategory.METADATA)
+            snapshot.categorize_as(SnapshotChangeCategory.METADATA, forward_only)
 
     def _get_orphaned_indirect_change_category(
         self, indirect_snapshot: Snapshot
@@ -769,10 +776,7 @@ class PlanBuilder:
             if snapshot.is_model and _is_breaking_kind_change(old, snapshot):
                 return False
         return (
-            snapshot.is_model
-            and snapshot.model.forward_only
-            and not snapshot.change_category
-            and bool(snapshot.previous_versions)
+            snapshot.is_model and snapshot.model.forward_only and bool(snapshot.previous_versions)
         )
 
     def _is_new_snapshot(self, snapshot: Snapshot) -> bool:
@@ -811,7 +815,7 @@ class PlanBuilder:
                 and not candidate.model.forward_only
                 and promoted.is_forward_only
                 and not promoted.is_paused
-                and not candidate.reuses_previous_version
+                and not candidate.is_no_rebuild
                 and promoted.version == candidate.version
             ):
                 raise PlanError(

{sqlmesh-0.208.2.dev1 → sqlmesh-0.208.2.dev3}/sqlmesh/core/snapshot/definition.py

@@ -76,6 +76,7 @@ class SnapshotChangeCategory(IntEnum):
 
     BREAKING = 1
     NON_BREAKING = 2
+    # FORWARD_ONLY category is deprecated and is kept for backwards compatibility.
     FORWARD_ONLY = 3
     INDIRECT_BREAKING = 4
     INDIRECT_NON_BREAKING = 5
@@ -336,6 +337,7 @@ class SnapshotInfoMixin(ModelKindMixin):
     base_table_name_override: t.Optional[str]
     dev_table_suffix: str
     table_naming_convention: TableNamingConvention = Field(default=TableNamingConvention.default)
+    forward_only: bool
 
     @cached_property
     def identifier(self) -> str:
@@ -383,7 +385,7 @@ class SnapshotInfoMixin(ModelKindMixin):
 
     @property
     def is_forward_only(self) -> bool:
-        return self.change_category == SnapshotChangeCategory.FORWARD_ONLY
+        return self.forward_only or self.change_category == SnapshotChangeCategory.FORWARD_ONLY
 
     @property
     def is_metadata(self) -> bool:
@@ -394,9 +396,18 @@ class SnapshotInfoMixin(ModelKindMixin):
         return self.change_category == SnapshotChangeCategory.INDIRECT_NON_BREAKING
 
     @property
-    def reuses_previous_version(self) -> bool:
-        return self.change_category in (
-            SnapshotChangeCategory.FORWARD_ONLY,
+    def is_no_rebuild(self) -> bool:
+        """Returns true if this snapshot doesn't require a rebuild in production."""
+        return self.forward_only or self.change_category in (
+            SnapshotChangeCategory.FORWARD_ONLY,  # Backwards compatibility
+            SnapshotChangeCategory.METADATA,
+            SnapshotChangeCategory.INDIRECT_NON_BREAKING,
+        )
+
+    @property
+    def is_no_preview(self) -> bool:
+        """Returns true if this snapshot doesn't require a preview in development."""
+        return self.forward_only and self.change_category in (
             SnapshotChangeCategory.METADATA,
             SnapshotChangeCategory.INDIRECT_NON_BREAKING,
         )
@@ -487,6 +498,7 @@ class SnapshotTableInfo(PydanticModel, SnapshotInfoMixin, frozen=True):
     custom_materialization: t.Optional[str] = None
     dev_table_suffix: str
     model_gateway: t.Optional[str] = None
+    forward_only: bool = False
 
     def __lt__(self, other: SnapshotTableInfo) -> bool:
         return self.name < other.name
@@ -614,6 +626,7 @@ class Snapshot(PydanticModel, SnapshotInfoMixin):
     table_naming_convention_: TableNamingConvention = Field(
         default=TableNamingConvention.default, alias="table_naming_convention"
     )
+    forward_only: bool = False
 
     @field_validator("ttl")
     @classmethod
@@ -1006,22 +1019,26 @@ class Snapshot(PydanticModel, SnapshotInfoMixin):
                 )
         return intervals
 
-    def categorize_as(self, category: SnapshotChangeCategory) -> None:
+    def categorize_as(self, category: SnapshotChangeCategory, forward_only: bool = False) -> None:
         """Assigns the given category to this snapshot.
 
         Args:
             category: The change category to assign to this snapshot.
+            forward_only: Whether or not this snapshot is applied going forward in production.
         """
+        assert category != SnapshotChangeCategory.FORWARD_ONLY, (
+            "FORWARD_ONLY change category is deprecated"
+        )
+
         self.dev_version_ = self.fingerprint.to_version()
-        reuse_previous_version = category in (
-            SnapshotChangeCategory.FORWARD_ONLY,
+        is_no_rebuild = forward_only or category in (
             SnapshotChangeCategory.INDIRECT_NON_BREAKING,
             SnapshotChangeCategory.METADATA,
         )
         if self.is_model and self.model.physical_version:
             # If the model has a pinned version then use that.
             self.version = self.model.physical_version
-        elif reuse_previous_version and self.previous_version:
+        elif is_no_rebuild and self.previous_version:
             previous_version = self.previous_version
             self.version = previous_version.data_version.version
             self.physical_schema_ = previous_version.physical_schema
@@ -1040,6 +1057,7 @@ class Snapshot(PydanticModel, SnapshotInfoMixin):
             self.version = self.fingerprint.to_version()
 
         self.change_category = category
+        self.forward_only = forward_only
 
     @property
     def categorized(self) -> bool:
@@ -1220,6 +1238,7 @@ class Snapshot(PydanticModel, SnapshotInfoMixin):
             dev_table_suffix=self.dev_table_suffix,
             model_gateway=self.model_gateway,
             table_naming_convention=self.table_naming_convention,  # type: ignore
+            forward_only=self.forward_only,
         )
 
     @property

{sqlmesh-0.208.2.dev1 → sqlmesh-0.208.2.dev3}/sqlmesh/core/snapshot/evaluator.py

@@ -338,7 +338,7 @@ class SnapshotEvaluator:
                 continue
             deployability_flags = [True]
             if (
-                snapshot.reuses_previous_version
+                snapshot.is_no_rebuild
                 or snapshot.is_managed
                 or (snapshot.is_model and snapshot.model.forward_only)
                 or (deployability_index and not deployability_index.is_deployable(snapshot))

{sqlmesh-0.208.2.dev1 → sqlmesh-0.208.2.dev3}/sqlmesh/core/state_sync/db/snapshot.py

@@ -727,6 +727,7 @@ class SharedVersionSnapshot(PydanticModel):
     disable_restatement: bool
     effective_from: t.Optional[TimeLike]
     raw_snapshot: t.Dict[str, t.Any]
+    forward_only: bool
 
     @property
     def snapshot_id(self) -> SnapshotId:
@@ -734,7 +735,7 @@ class SharedVersionSnapshot(PydanticModel):
 
     @property
     def is_forward_only(self) -> bool:
-        return self.change_category == SnapshotChangeCategory.FORWARD_ONLY
+        return self.forward_only or self.change_category == SnapshotChangeCategory.FORWARD_ONLY
 
     @property
     def normalized_effective_from_ts(self) -> t.Optional[int]:
@@ -797,4 +798,5 @@ class SharedVersionSnapshot(PydanticModel):
             disable_restatement=raw_node.get("kind", {}).get("disable_restatement", False),
             effective_from=raw_snapshot.get("effective_from"),
             raw_snapshot=raw_snapshot,
+            forward_only=raw_snapshot.get("forward_only", False),
         )

{sqlmesh-0.208.2.dev1 → sqlmesh-0.208.2.dev3}/sqlmesh.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlmesh
-Version: 0.208.2.dev1
+Version: 0.208.2.dev3
 Summary: Next-generation data transformation framework
 Author-email: "TobikoData Inc." <engineering@tobikodata.com>
 License:                                  Apache License

{sqlmesh-0.208.2.dev1 → sqlmesh-0.208.2.dev3}/tests/conftest.py

@@ -438,7 +438,7 @@ def make_snapshot_on_destructive_change(make_snapshot: t.Callable) -> t.Callable
                     metadata_hash="test_metadata_hash",
                 ),
                 version="test_version",
-                change_category=SnapshotChangeCategory.FORWARD_ONLY,
+                change_category=SnapshotChangeCategory.NON_BREAKING,
                 dev_table_suffix="dev",
             ),
         )

{sqlmesh-0.208.2.dev1 → sqlmesh-0.208.2.dev3}/tests/core/analytics/test_collector.py

@@ -218,7 +218,7 @@ def test_on_snapshots_created(
         context.get_snapshot("sushi.waiter_revenue_by_day"),
         context.get_snapshot("sushi.top_waiters"),
     ]
-    new_snapshots[0].categorize_as(SnapshotChangeCategory.FORWARD_ONLY)
+    new_snapshots[0].categorize_as(SnapshotChangeCategory.BREAKING, forward_only=True)
     new_snapshots[0].effective_from = "2024-01-01"
     new_snapshots[0].version = "test_version"
 
@@ -239,7 +239,7 @@ def test_on_snapshots_created(
             "node_type": "model",
             "model_kind": "incremental_by_time_range",
             "is_sql": False,
-            "change_category": "forward_only",
+            "change_category": "breaking",
             "dialect": "duckdb",
             "audits_count": 0,
             "effective_from_set": True,

{sqlmesh-0.208.2.dev1 → sqlmesh-0.208.2.dev3}/tests/core/engine_adapter/integration/test_integration.py

@@ -2087,7 +2087,9 @@ def test_managed_model_upstream_forward_only(ctx: TestContext):
     plan_1 = _run_plan(context)
 
     assert plan_1.snapshot_for(model_a).change_category == SnapshotChangeCategory.BREAKING
+    assert not plan_1.snapshot_for(model_a).is_forward_only
     assert plan_1.snapshot_for(model_b).change_category == SnapshotChangeCategory.BREAKING
+    assert not plan_1.snapshot_for(model_b).is_forward_only
 
     # so far so good, model_a should exist as a normal table, model b should be a managed table and the prod views should exist
     assert len(plan_1.schema_metadata.views) == 2
@@ -2134,8 +2136,10 @@ def test_managed_model_upstream_forward_only(ctx: TestContext):
 
     assert plan_2.plan.has_changes
     assert len(plan_2.plan.modified_snapshots) == 2
-    assert plan_2.snapshot_for(new_model_a).change_category == SnapshotChangeCategory.FORWARD_ONLY
+    assert plan_2.snapshot_for(new_model_a).change_category == SnapshotChangeCategory.NON_BREAKING
+    assert plan_2.snapshot_for(new_model_a).is_forward_only
     assert plan_2.snapshot_for(model_b).change_category == SnapshotChangeCategory.NON_BREAKING
+    assert not plan_2.snapshot_for(model_b).is_forward_only
 
     # verify that the new snapshots were created correctly
     # the forward-only change to model A should be in a new table separate from the one created in the first plan
@@ -2207,8 +2211,10 @@ def test_managed_model_upstream_forward_only(ctx: TestContext):
     plan_4 = _run_plan(context)
 
     assert plan_4.plan.has_changes
-    assert plan_4.snapshot_for(model_a).change_category == SnapshotChangeCategory.FORWARD_ONLY
+    assert plan_4.snapshot_for(model_a).change_category == SnapshotChangeCategory.NON_BREAKING
+    assert plan_4.snapshot_for(model_a).is_forward_only
     assert plan_4.snapshot_for(model_b).change_category == SnapshotChangeCategory.NON_BREAKING
+    assert not plan_4.snapshot_for(model_b).is_forward_only
 
     # verify the Model B table is created as a managed table in prod
     assert plan_4.table_name_for(model_b) == plan_3.table_name_for(

{sqlmesh-0.208.2.dev1 → sqlmesh-0.208.2.dev3}/tests/core/state_sync/test_state_sync.py

@@ -139,7 +139,7 @@ def test_push_snapshots(
         state_sync.push_snapshots([snapshot_a, snapshot_b])
 
     snapshot_a.categorize_as(SnapshotChangeCategory.BREAKING)
-    snapshot_b.categorize_as(SnapshotChangeCategory.FORWARD_ONLY)
+    snapshot_b.categorize_as(SnapshotChangeCategory.BREAKING, forward_only=True)
     snapshot_b.version = "2"
 
     state_sync.push_snapshots([snapshot_a, snapshot_b])
@@ -258,7 +258,8 @@ def test_add_interval(
         (to_timestamp("2020-01-05"), to_timestamp("2020-01-11")),
     ]
 
-    snapshot.change_category = SnapshotChangeCategory.FORWARD_ONLY
+    snapshot.change_category = SnapshotChangeCategory.BREAKING
+    snapshot.forward_only = True
     state_sync.add_interval(snapshot, to_datetime("2020-01-16"), "2020-01-20", is_dev=True)
     intervals = get_snapshot_intervals(snapshot)
     assert intervals.intervals == [
@@ -1144,7 +1145,7 @@ def test_delete_expired_snapshots(state_sync: EngineAdapterStateSync, make_snaps
         ),
     )
     new_snapshot.ttl = "in 10 seconds"
-    new_snapshot.categorize_as(SnapshotChangeCategory.FORWARD_ONLY)
+    new_snapshot.categorize_as(SnapshotChangeCategory.BREAKING, forward_only=True)
     new_snapshot.version = snapshot.version
     new_snapshot.updated_ts = now_ts - 11000
 
@@ -1298,7 +1299,7 @@ def test_delete_expired_snapshots_dev_table_cleanup_only(
         ),
     )
     new_snapshot.ttl = "in 10 seconds"
-    new_snapshot.categorize_as(SnapshotChangeCategory.FORWARD_ONLY)
+    new_snapshot.categorize_as(SnapshotChangeCategory.BREAKING, forward_only=True)
     new_snapshot.version = snapshot.version
     new_snapshot.updated_ts = now_ts - 5000
 
@@ -1338,7 +1339,7 @@ def test_delete_expired_snapshots_shared_dev_table(
         ),
     )
     new_snapshot.ttl = "in 10 seconds"
-    new_snapshot.categorize_as(SnapshotChangeCategory.FORWARD_ONLY)
+    new_snapshot.categorize_as(SnapshotChangeCategory.BREAKING, forward_only=True)
     new_snapshot.version = snapshot.version
     new_snapshot.dev_version_ = snapshot.dev_version
     new_snapshot.updated_ts = now_ts - 5000
@@ -1430,7 +1431,7 @@ def test_delete_expired_snapshots_cleanup_intervals(
         ),
     )
     new_snapshot.ttl = "in 10 seconds"
-    new_snapshot.categorize_as(SnapshotChangeCategory.FORWARD_ONLY)
+    new_snapshot.categorize_as(SnapshotChangeCategory.BREAKING, forward_only=True)
     new_snapshot.version = snapshot.version
     new_snapshot.updated_ts = now_ts - 12000
 
@@ -1497,7 +1498,7 @@ def test_delete_expired_snapshots_cleanup_intervals_shared_version(
         ),
     )
     new_snapshot.ttl = "in 10 seconds"
-    new_snapshot.categorize_as(SnapshotChangeCategory.FORWARD_ONLY)
+    new_snapshot.categorize_as(SnapshotChangeCategory.BREAKING, forward_only=True)
     new_snapshot.version = snapshot.version
     new_snapshot.updated_ts = now_ts - 5000
 
@@ -1612,7 +1613,7 @@ def test_delete_expired_snapshots_cleanup_intervals_shared_dev_version(
         ),
     )
     new_snapshot.ttl = "in 10 seconds"
-    new_snapshot.categorize_as(SnapshotChangeCategory.FORWARD_ONLY)
+    new_snapshot.categorize_as(SnapshotChangeCategory.BREAKING, forward_only=True)
     new_snapshot.version = snapshot.version
     new_snapshot.dev_version_ = snapshot.dev_version
     new_snapshot.updated_ts = now_ts - 5000
@@ -1740,7 +1741,7 @@ def test_compact_intervals_after_cleanup(
     )
     snapshot_b.previous_versions = snapshot_a.all_versions
     snapshot_b.ttl = "in 10 seconds"
-    snapshot_b.categorize_as(SnapshotChangeCategory.FORWARD_ONLY)
+    snapshot_b.categorize_as(SnapshotChangeCategory.BREAKING, forward_only=True)
     snapshot_b.updated_ts = now_ts - 12000
 
     # An indirect non-breaking change on top of the forward-only change. Not expired.
@@ -1872,7 +1873,7 @@ def test_unpause_snapshots(state_sync: EngineAdapterStateSync, make_snapshot: t.
     new_snapshot = make_snapshot(
         SqlModel(name="test_snapshot", query=parse_one("select 2, ds"), cron="@daily")
     )
-    new_snapshot.categorize_as(SnapshotChangeCategory.FORWARD_ONLY)
+    new_snapshot.categorize_as(SnapshotChangeCategory.BREAKING, forward_only=True)
     new_snapshot.version = "a"
 
     assert not new_snapshot.unpaused_ts
@@ -1917,7 +1918,7 @@ def test_unpause_snapshots_hourly(state_sync: EngineAdapterStateSync, make_snaps
             interval_unit="hour",
         )
     )
-    new_snapshot.categorize_as(SnapshotChangeCategory.FORWARD_ONLY)
+    new_snapshot.categorize_as(SnapshotChangeCategory.BREAKING, forward_only=True)
     new_snapshot.version = "a"
 
     assert not new_snapshot.unpaused_ts
@@ -1974,7 +1975,7 @@ def test_unrestorable_snapshot(state_sync: EngineAdapterStateSync, make_snapshot
     new_forward_only_snapshot = make_snapshot(
         SqlModel(name="test_snapshot", query=parse_one("select 3, ds"), cron="@daily")
     )
-    new_forward_only_snapshot.categorize_as(SnapshotChangeCategory.FORWARD_ONLY)
+    new_forward_only_snapshot.categorize_as(SnapshotChangeCategory.BREAKING, forward_only=True)
     new_forward_only_snapshot.version = "a"
 
     assert not new_forward_only_snapshot.unpaused_ts
@@ -2015,7 +2016,7 @@ def test_unpause_snapshots_remove_intervals(
         SqlModel(name="test_snapshot", query=parse_one("select 2, ds"), cron="@daily"),
         version="a",
     )
-    new_snapshot.categorize_as(SnapshotChangeCategory.FORWARD_ONLY)
+    new_snapshot.categorize_as(SnapshotChangeCategory.BREAKING, forward_only=True)
     new_snapshot.version = "a"
     new_snapshot.effective_from = "2023-01-03"
     state_sync.push_snapshots([new_snapshot])
@@ -2053,7 +2054,7 @@ def test_unpause_snapshots_remove_intervals_disabled_restatement(
         SqlModel(name="test_snapshot", query=parse_one("select 2, ds"), cron="@daily", kind=kind),
         version="a",
     )
-    new_snapshot.categorize_as(SnapshotChangeCategory.FORWARD_ONLY)
+    new_snapshot.categorize_as(SnapshotChangeCategory.BREAKING, forward_only=True)
     new_snapshot.version = "a"
     new_snapshot.effective_from = "2023-01-03"
     state_sync.push_snapshots([new_snapshot])
@@ -3019,7 +3020,7 @@ def test_seed_model_metadata_update(
     model = model.copy(update={"owner": "jen"})
     new_snapshot = make_snapshot(model)
     new_snapshot.previous_versions = snapshot.all_versions
-    new_snapshot.categorize_as(SnapshotChangeCategory.FORWARD_ONLY)
+    new_snapshot.categorize_as(SnapshotChangeCategory.BREAKING, forward_only=True)
 
     assert snapshot.fingerprint != new_snapshot.fingerprint
     assert snapshot.version == new_snapshot.version

{sqlmesh-0.208.2.dev1 → sqlmesh-0.208.2.dev3}/tests/core/test_context.py

@@ -647,6 +647,9 @@ def test_clear_caches(tmp_path: pathlib.Path):
     assert not cache_dir.exists()
     assert models_dir.exists()
 
+    # Ensure that we don't initialize a CachingStateSync only to clear its (empty) caches
+    assert context._state_sync is None
+
     # Test clearing caches when cache directory doesn't exist
     # This should not raise an exception
     context.clear_caches()
@@ -1124,6 +1127,7 @@ def test_unrestorable_snapshot(sushi_context: Context) -> None:
         no_prompts=True,
         forward_only=True,
         allow_destructive_models=["memory.sushi.test_unrestorable"],
+        categorizer_config=CategorizerConfig.all_full(),
     )
 
     sushi_context.upsert_model(model_v1)
@@ -1132,6 +1136,7 @@ def test_unrestorable_snapshot(sushi_context: Context) -> None:
         no_prompts=True,
         forward_only=True,
         allow_destructive_models=["memory.sushi.test_unrestorable"],
+        categorizer_config=CategorizerConfig.all_full(),
     )
     model_v1_new_snapshot = sushi_context.get_snapshot(
         "memory.sushi.test_unrestorable", raise_if_missing=True