fixes after rebase

Author: izeigerman

sqlmesh/core/context.py

@@ -1616,6 +1616,11 @@ def plan_builder(
             max_interval_end_per_model,
         )
 
+        if not self.config.virtual_environment_mode.is_full:
+            forward_only = True
+        elif forward_only is None:
+            forward_only = self.config.plan.forward_only
+
         return self.PLAN_BUILDER_TYPE(
             context_diff=context_diff,
             start=start,
@@ -1628,9 +1633,7 @@ def plan_builder(
             skip_backfill=skip_backfill,
             empty_backfill=empty_backfill,
             is_dev=is_dev,
-            forward_only=(
-                forward_only if forward_only is not None else self.config.plan.forward_only
-            ),
+            forward_only=forward_only,
             allow_destructive_models=expanded_destructive_models,
             environment_ttl=environment_ttl,
             environment_suffix_target=self.config.environment_suffix_target,

sqlmesh/core/plan/builder.py

@@ -609,13 +609,13 @@ def _categorize_snapshot(
 
         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:
+            should_force_rebuild = _should_force_rebuild(old, new)
+            if should_force_rebuild 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:
+                if should_force_rebuild:
                     snapshot.categorize_as(SnapshotChangeCategory.BREAKING, forward_only)
                     return
 
@@ -773,7 +773,7 @@ def _is_forward_only_change(self, s_id: SnapshotId) -> bool:
         if snapshot.name in self._context_diff.modified_snapshots:
             _, old = self._context_diff.modified_snapshots[snapshot.name]
             # If the model kind has changed in a breaking way, then we can't consider this to be a forward-only change.
-            if snapshot.is_model and _should_force_breaking_change(old, snapshot):
+            if snapshot.is_model and _should_force_rebuild(old, snapshot):
                 return False
         return (
             snapshot.is_model and snapshot.model.forward_only and bool(snapshot.previous_versions)
@@ -894,7 +894,7 @@ def _modified_and_added_snapshots(self) -> t.List[Snapshot]:
         ]
 
 
-def _should_force_breaking_change(old: Snapshot, new: Snapshot) -> bool:
+def _should_force_rebuild(old: Snapshot, new: Snapshot) -> bool:
     if old.virtual_environment_mode != new.virtual_environment_mode:
         # If the virtual environment mode has changed, then it's a breaking change
         return True

sqlmesh/core/snapshot/definition.py

@@ -1408,6 +1408,7 @@ def requires_schema_migration_in_prod(self) -> bool:
                 or self.model.forward_only
                 or bool(self.model.physical_version)
                 or self.is_view
+                or not self.virtual_environment_mode.is_full
             )
         )
 

tests/core/test_integration.py

@@ -2505,76 +2505,22 @@ def test_virtual_environment_mode_dev_only(init_and_plan_context: t.Callable):
     )[0]
     assert min_event_date == to_date("2023-01-07")
 
-    # Make sure the changed models are fully rebuilt when deploying to prod
+    # Make sure the changes are applied without backfill in prod
     plan_prod = context.plan_builder("prod").build()
-    assert plan_prod.requires_backfill
-    assert plan_prod.missing_intervals == [
-        SnapshotIntervals(
-            snapshot_id=context.get_snapshot("sushi.top_waiters").snapshot_id,
-            intervals=[
-                (to_timestamp("2023-01-01"), to_timestamp("2023-01-02")),
-                (to_timestamp("2023-01-02"), to_timestamp("2023-01-03")),
-                (to_timestamp("2023-01-03"), to_timestamp("2023-01-04")),
-                (to_timestamp("2023-01-04"), to_timestamp("2023-01-05")),
-                (to_timestamp("2023-01-05"), to_timestamp("2023-01-06")),
-                (to_timestamp("2023-01-06"), to_timestamp("2023-01-07")),
-                (to_timestamp("2023-01-07"), to_timestamp("2023-01-08")),
-            ],
-        ),
-        SnapshotIntervals(
-            snapshot_id=context.get_snapshot("sushi.waiter_revenue_by_day").snapshot_id,
-            intervals=[
-                (to_timestamp("2023-01-01"), to_timestamp("2023-01-02")),
-                (to_timestamp("2023-01-02"), to_timestamp("2023-01-03")),
-                (to_timestamp("2023-01-03"), to_timestamp("2023-01-04")),
-                (to_timestamp("2023-01-04"), to_timestamp("2023-01-05")),
-                (to_timestamp("2023-01-05"), to_timestamp("2023-01-06")),
-                (to_timestamp("2023-01-06"), to_timestamp("2023-01-07")),
-                (to_timestamp("2023-01-07"), to_timestamp("2023-01-08")),
-            ],
-        ),
-    ]
+    assert not plan_prod.requires_backfill
+    assert not plan_prod.missing_intervals
     context.apply(plan_prod)
     assert "one" in context.engine_adapter.columns("sushi.waiter_revenue_by_day")
-    assert (
-        context.engine_adapter.fetchone(
-            "SELECT COUNT(*) FROM sushi.waiter_revenue_by_day WHERE one is NULL"
-        )[0]
-        == 0
-    )
 
     # Make sure the revert of a breaking changes results in a full rebuild
     context.upsert_model(original_model)
     assert context.get_snapshot(original_model.name).fingerprint == original_fingerprint
 
-    plan_prod = context.plan_builder("prod").build()
-    assert plan_prod.requires_backfill
-    assert plan_prod.missing_intervals == [
-        SnapshotIntervals(
-            snapshot_id=context.get_snapshot("sushi.top_waiters").snapshot_id,
-            intervals=[
-                (to_timestamp("2023-01-01"), to_timestamp("2023-01-02")),
-                (to_timestamp("2023-01-02"), to_timestamp("2023-01-03")),
-                (to_timestamp("2023-01-03"), to_timestamp("2023-01-04")),
-                (to_timestamp("2023-01-04"), to_timestamp("2023-01-05")),
-                (to_timestamp("2023-01-05"), to_timestamp("2023-01-06")),
-                (to_timestamp("2023-01-06"), to_timestamp("2023-01-07")),
-                (to_timestamp("2023-01-07"), to_timestamp("2023-01-08")),
-            ],
-        ),
-        SnapshotIntervals(
-            snapshot_id=context.get_snapshot("sushi.waiter_revenue_by_day").snapshot_id,
-            intervals=[
-                (to_timestamp("2023-01-01"), to_timestamp("2023-01-02")),
-                (to_timestamp("2023-01-02"), to_timestamp("2023-01-03")),
-                (to_timestamp("2023-01-03"), to_timestamp("2023-01-04")),
-                (to_timestamp("2023-01-04"), to_timestamp("2023-01-05")),
-                (to_timestamp("2023-01-05"), to_timestamp("2023-01-06")),
-                (to_timestamp("2023-01-06"), to_timestamp("2023-01-07")),
-                (to_timestamp("2023-01-07"), to_timestamp("2023-01-08")),
-            ],
-        ),
-    ]
+    plan_prod = context.plan_builder(
+        "prod", allow_destructive_models=["sushi.waiter_revenue_by_day"]
+    ).build()
+    assert not plan_prod.requires_backfill
+    assert not plan_prod.missing_intervals
     context.apply(plan_prod)
     assert "one" not in context.engine_adapter.columns("sushi.waiter_revenue_by_day")