sqlmesh 0.192.2.dev6__py3-none-any.whl → 0.192.3.dev2__py3-none-any.whl

sqlmesh/core/plan/explainer.py

@@ -17,7 +17,7 @@ from sqlmesh.core.state_sync import StateReader
 from sqlmesh.core.snapshot.definition import (
     SnapshotInfoMixin,
 )
-from sqlmesh.utils import Verbosity, rich as srich
+from sqlmesh.utils import Verbosity, rich as srich, to_snake_case
 from sqlmesh.utils.date import to_ts
 from sqlmesh.utils.errors import SQLMeshError
 
@@ -73,7 +73,7 @@ class RichExplainerConsole(ExplainerConsole):
     def explain(self, stages: t.List[stages.PlanStage]) -> None:
         tree = Tree("[bold]Explained plan[/bold]")
         for stage in stages:
-            handler_name = f"visit_{_to_snake_case(stage.__class__.__name__)}"
+            handler_name = f"visit_{to_snake_case(stage.__class__.__name__)}"
             if not hasattr(self, handler_name):
                 logger.error("Unexpected stage: %s", stage.__class__.__name__)
                 continue
@@ -97,6 +97,9 @@ class RichExplainerConsole(ExplainerConsole):
             "[bold]Validate SQL and create physical layer tables and views if they do not exist[/bold]"
         )
         for snapshot in stage.snapshots:
+            if snapshot.snapshot_id not in stage.snapshots_with_missing_intervals:
+                continue
+
             is_deployable = (
                 stage.deployability_index.is_deployable(snapshot)
                 if self.environment_naming_info.name != c.PROD
@@ -114,7 +117,9 @@ class RichExplainerConsole(ExplainerConsole):
 
             if snapshot.is_view:
                 create_tree = Tree("Create view if it doesn't exist")
-            elif snapshot.is_forward_only and snapshot.previous_versions:
+            elif (
+                snapshot.is_forward_only and snapshot.previous_versions and not snapshot.is_managed
+            ):
                 prod_table = snapshot.table_name(True)
                 create_tree = Tree(
                     f"Clone {prod_table} into {table_name} and then update its schema if it doesn't exist"
@@ -224,7 +229,7 @@ class RichExplainerConsole(ExplainerConsole):
             "[bold]Delete views in the virtual layer for models that were removed[/bold]"
         )
         for snapshot in stage.demoted_snapshots:
-            display_name = self._display_name(snapshot)
+            display_name = self._display_name(snapshot, stage.demoted_environment_naming_info)
             demote_tree.add(display_name)
 
         if stage.promoted_snapshots:
@@ -233,14 +238,31 @@ class RichExplainerConsole(ExplainerConsole):
             tree.add(self._limit_tree(demote_tree))
         return tree
 
+    def visit_create_snapshot_records_stage(
+        self, stage: stages.CreateSnapshotRecordsStage
+    ) -> t.Optional[Tree]:
+        return None
+
     def visit_environment_record_update_stage(
         self, stage: stages.EnvironmentRecordUpdateStage
     ) -> t.Optional[Tree]:
         return None
 
-    def _display_name(self, snapshot: SnapshotInfoMixin) -> str:
+    def visit_unpause_stage(self, stage: stages.UnpauseStage) -> t.Optional[Tree]:
+        return None
+
+    def visit_finalize_environment_stage(
+        self, stage: stages.FinalizeEnvironmentStage
+    ) -> t.Optional[Tree]:
+        return None
+
+    def _display_name(
+        self,
+        snapshot: SnapshotInfoMixin,
+        environment_naming_info: t.Optional[EnvironmentNamingInfo] = None,
+    ) -> str:
         return snapshot.display_name(
-            self.environment_naming_info,
+            environment_naming_info or self.environment_naming_info,
             self.default_catalog if self.verbosity < Verbosity.VERY_VERBOSE else None,
             dialect=self.dialect,
         )
@@ -273,9 +295,3 @@ def _get_explainer_console(
         verbosity=console.verbosity,
         console=console.console,
     )
-
-
-def _to_snake_case(name: str) -> str:
-    return "".join(
-        f"_{c.lower()}" if c.isupper() and idx != 0 else c.lower() for idx, c in enumerate(name)
-    )

sqlmesh/core/plan/stages.py

@@ -1,11 +1,8 @@
 import typing as t
 
 from dataclasses import dataclass
+from sqlmesh.core.environment import EnvironmentStatements, EnvironmentNamingInfo
 from sqlmesh.core.plan.definition import EvaluatablePlan
-from sqlmesh.core.plan.evaluator import (
-    get_audit_only_snapshots,
-    get_snapshots_to_create,
-)
 from sqlmesh.core.state_sync import StateReader
 from sqlmesh.core.scheduler import merged_missing_intervals, SnapshotToIntervals
 from sqlmesh.core.snapshot.definition import (
@@ -19,68 +16,193 @@ from sqlmesh.core.snapshot.definition import (
 
 @dataclass
 class BeforeAllStage:
-    statements: t.List[str]
+    """Run environment statements before every other stage.
+
+    Args:
+        statements: Environment statements to run before every other stage.
+        all_snapshots: All snapshots in the plan by name.
+    """
+
+    statements: t.List[EnvironmentStatements]
+    all_snapshots: t.Dict[str, Snapshot]
 
 
 @dataclass
 class AfterAllStage:
-    statements: t.List[str]
+    """Run environment statements after all other stages.
+
+    Args:
+        statements: Environment statements to run after all other stages.
+        all_snapshots: All snapshots in the plan by name.
+    """
+
+    statements: t.List[EnvironmentStatements]
+    all_snapshots: t.Dict[str, Snapshot]
+
+
+@dataclass
+class CreateSnapshotRecordsStage:
+    """Create new snapshot reecords in the state.
+
+    Args:
+        snapshots: New snapshots to create records for.
+    """
+
+    snapshots: t.List[Snapshot]
 
 
 @dataclass
 class PhysicalLayerUpdateStage:
+    """Update the physical layer by creating physical tables and views for given snapshots.
+
+    Args:
+        snapshots: Snapshots to create physical tables and views for. This collection can be empty in which case
+            no physical layer update is needed. This can be useful to report the lack of physical layer updates
+            back to the user.
+        all_snapshots: All snapshots in the plan by snapshot ID.
+        snapshots_with_missing_intervals: Snapshots that have missing intervals.
+        deployability_index: Deployability index for this stage.
+    """
+
     snapshots: t.List[Snapshot]
+    all_snapshots: t.Dict[SnapshotId, Snapshot]
+    snapshots_with_missing_intervals: t.Set[SnapshotId]
     deployability_index: DeployabilityIndex
 
 
 @dataclass
 class AuditOnlyRunStage:
+    """Run audits only for given snapshots.
+
+    Args:
+        snapshots: Snapshots to run audits for.
+    """
+
     snapshots: t.List[Snapshot]
 
 
 @dataclass
 class RestatementStage:
+    """Restate intervals for given snapshots.
+
+    Args:
+        snapshot_intervals: Intervals to restate.
+        all_snapshots: All snapshots in the plan by name.
+    """
+
     snapshot_intervals: t.Dict[SnapshotTableInfo, Interval]
+    all_snapshots: t.Dict[str, Snapshot]
 
 
 @dataclass
 class BackfillStage:
+    """Backfill given missing intervals.
+
+    Args:
+        snapshot_to_intervals: Intervals to backfill. This collection can be empty in which case no backfill is needed.
+            This can be useful to report the lack of backfills back to the user.
+        all_snapshots: All snapshots in the plan by name.
+        deployability_index: Deployability index for this stage.
+        before_promote: Whether this stage is before the promotion stage.
+    """
+
     snapshot_to_intervals: SnapshotToIntervals
+    all_snapshots: t.Dict[str, Snapshot]
     deployability_index: DeployabilityIndex
     before_promote: bool = True
 
 
+@dataclass
+class EnvironmentRecordUpdateStage:
+    """Update the environment record in the state.
+
+    Args:
+        no_gaps_snapshot_names: Names of snapshots for which there should be no interval gaps.
+    """
+
+    no_gaps_snapshot_names: t.Set[str]
+
+
 @dataclass
 class MigrateSchemasStage:
+    """Migrate schemas of physical tables for given snapshots.
+
+    Args:
+        snapshots: Snapshots to migrate schemas for.
+        all_snapshots: All snapshots in the plan by snapshot ID.
+        deployability_index: Deployability index for this stage.
+    """
+
     snapshots: t.List[Snapshot]
+    all_snapshots: t.Dict[SnapshotId, Snapshot]
+    deployability_index: DeployabilityIndex
 
 
 @dataclass
 class VirtualLayerUpdateStage:
+    """Update the virtual layer by creating and deleting views for given snapshots.
+
+    Args:
+        promoted_snapshots: Snapshots to create views for.
+        demoted_snapshots: Snapshots to delete views for.
+        demoted_environment_naming_info: Environment naming info of the previous environment record.
+        all_snapshots: All snapshots in the plan by snapshot ID.
+        deployability_index: Deployability index for this stage.
+    """
+
     promoted_snapshots: t.Set[SnapshotTableInfo]
     demoted_snapshots: t.Set[SnapshotTableInfo]
+    demoted_environment_naming_info: t.Optional[EnvironmentNamingInfo]
+    all_snapshots: t.Dict[SnapshotId, Snapshot]
     deployability_index: DeployabilityIndex
 
 
 @dataclass
-class EnvironmentRecordUpdateStage:
+class UnpauseStage:
+    """Unpause given snapshots that are being deployed to prod.
+
+    Args:
+        promoted_snapshots: Snapshots to unpause.
+    """
+
+    promoted_snapshots: t.Set[SnapshotTableInfo]
+
+
+@dataclass
+class FinalizeEnvironmentStage:
+    """Finalize the enviornment record in the state.
+
+    Finalization means that all stages have been applied and that the environment has been transitioned
+    to the new state successfully. This should be the last stage in the plan application process.
+    """
+
     pass
 
 
 PlanStage = t.Union[
     BeforeAllStage,
     AfterAllStage,
+    CreateSnapshotRecordsStage,
     PhysicalLayerUpdateStage,
     AuditOnlyRunStage,
     RestatementStage,
     BackfillStage,
+    EnvironmentRecordUpdateStage,
     MigrateSchemasStage,
     VirtualLayerUpdateStage,
-    EnvironmentRecordUpdateStage,
+    UnpauseStage,
+    FinalizeEnvironmentStage,
 ]
 
 
 class PlanStagesBuilder:
+    """The builder for the plan stages.
+
+    Args:
+        state_reader: The state reader to use to read the snapshots and environment.
+        default_catalog: The default catalog to use for the snapshots.
+    """
+
     def __init__(
         self,
         state_reader: StateReader,
@@ -90,6 +212,16 @@ class PlanStagesBuilder:
         self.default_catalog = default_catalog
 
     def build(self, plan: EvaluatablePlan) -> t.List[PlanStage]:
+        """Builds the plan stages for the given plan.
+
+        NOTE: Building the plan stages should NOT produce any side effects in the state or the data warehouse.
+
+        Args:
+            plan: The plan to build the stages for.
+
+        Returns:
+            A list of plan stages.
+        """
         new_snapshots = {s.snapshot_id: s for s in plan.new_snapshots}
         stored_snapshots = self.state_reader.get_snapshots(plan.environment.snapshots)
         snapshots = {**new_snapshots, **stored_snapshots}
@@ -99,6 +231,8 @@ class PlanStagesBuilder:
             s.snapshot_id for s in snapshots.values() if plan.is_selected_for_backfill(s.name)
         }
 
+        self._adjust_intervals(snapshots_by_name, plan)
+
         deployability_index = DeployabilityIndex.create(snapshots, start=plan.start)
         deployability_index_for_creation = deployability_index
         if plan.is_dev:
@@ -119,8 +253,9 @@ class PlanStagesBuilder:
                 s
                 for s in snapshots.values()
                 if s.is_paused
-                and s.is_materialized
-                and not deployability_index_for_creation.is_representative(s)
+                and s.is_model
+                and not s.is_symbolic
+                and (not deployability_index_for_creation.is_representative(s) or s.is_view)
             ]
 
         snapshots_to_intervals = self._missing_intervals(
@@ -138,19 +273,26 @@ class PlanStagesBuilder:
                 elif snapshot.snapshot_id in after_promote_snapshots:
                     missing_intervals_after_promote[snapshot] = intervals
 
+        promoted_snapshots, demoted_snapshots, demoted_environment_naming_info = (
+            self._get_promoted_demoted_snapshots(plan)
+        )
+
         stages: t.List[PlanStage] = []
 
-        before_all_stage = self._get_before_all_stage(plan)
+        before_all_stage = self._get_before_all_stage(plan, snapshots_by_name)
         if before_all_stage:
             stages.append(before_all_stage)
 
+        if plan.new_snapshots:
+            stages.append(CreateSnapshotRecordsStage(snapshots=plan.new_snapshots))
+
         stages.append(
             self._get_physical_layer_update_stage(
                 plan, snapshots, snapshots_to_intervals, deployability_index_for_creation
             )
         )
 
-        audit_only_snapshots = get_audit_only_snapshots(new_snapshots, self.state_reader)
+        audit_only_snapshots = self._get_audit_only_snapshots(new_snapshots)
         if audit_only_snapshots:
             stages.append(AuditOnlyRunStage(snapshots=list(audit_only_snapshots.values())))
 
@@ -162,53 +304,101 @@ class PlanStagesBuilder:
             stages.append(
                 BackfillStage(
                     snapshot_to_intervals=missing_intervals_before_promote,
+                    all_snapshots=snapshots_by_name,
                     deployability_index=deployability_index,
                 )
             )
         elif not needs_backfill:
             # Append an empty backfill stage so that explainer can show that the stage is skipped
             stages.append(
-                BackfillStage(snapshot_to_intervals={}, deployability_index=deployability_index)
+                BackfillStage(
+                    snapshot_to_intervals={},
+                    all_snapshots=snapshots_by_name,
+                    deployability_index=deployability_index,
+                )
             )
 
-        stages.append(EnvironmentRecordUpdateStage())
+        stages.append(
+            EnvironmentRecordUpdateStage(
+                no_gaps_snapshot_names={s.name for s in before_promote_snapshots}
+            )
+        )
 
         if snapshots_with_schema_migration:
-            stages.append(MigrateSchemasStage(snapshots=snapshots_with_schema_migration))
+            stages.append(
+                MigrateSchemasStage(
+                    snapshots=snapshots_with_schema_migration,
+                    all_snapshots=snapshots,
+                    deployability_index=deployability_index_for_creation,
+                )
+            )
+
+        if not plan.is_dev and not plan.ensure_finalized_snapshots and promoted_snapshots:
+            # Only unpause at this point if we don't have to use the finalized snapshots
+            # for subsequent plan applications. Otherwise, unpause right before updating
+            # the virtual layer.
+            stages.append(UnpauseStage(promoted_snapshots=promoted_snapshots))
 
         if missing_intervals_after_promote:
             stages.append(
                 BackfillStage(
                     snapshot_to_intervals=missing_intervals_after_promote,
+                    all_snapshots=snapshots_by_name,
                     deployability_index=deployability_index,
                 )
             )
 
-        virtual_layer_update_stage = self._get_virtual_layer_update_stage(plan, deployability_index)
+        if not plan.is_dev and plan.ensure_finalized_snapshots and promoted_snapshots:
+            # Unpause right before updating the virtual layer and finalizing the environment in case when
+            # we need to use the finalized snapshots for subsequent plan applications.
+            # Otherwise, unpause right after updatig the environment record.
+            stages.append(UnpauseStage(promoted_snapshots=promoted_snapshots))
+
+        virtual_layer_update_stage = self._get_virtual_layer_update_stage(
+            promoted_snapshots,
+            demoted_snapshots,
+            demoted_environment_naming_info,
+            snapshots,
+            deployability_index,
+        )
         if virtual_layer_update_stage:
             stages.append(virtual_layer_update_stage)
 
-        after_all_stage = self._get_after_all_stage(plan)
+        stages.append(FinalizeEnvironmentStage())
+
+        after_all_stage = self._get_after_all_stage(plan, snapshots_by_name)
         if after_all_stage:
             stages.append(after_all_stage)
 
         return stages
 
-    def _get_before_all_stage(self, plan: EvaluatablePlan) -> t.Optional[BeforeAllStage]:
+    def _get_before_all_stage(
+        self, plan: EvaluatablePlan, snapshots_by_name: t.Dict[str, Snapshot]
+    ) -> t.Optional[BeforeAllStage]:
         before_all = [
-            statement
+            environment_statements
             for environment_statements in plan.environment_statements or []
-            for statement in environment_statements.before_all
+            if environment_statements.before_all
         ]
-        return BeforeAllStage(statements=before_all) if before_all else None
+        return (
+            BeforeAllStage(statements=before_all, all_snapshots=snapshots_by_name)
+            if before_all
+            else None
+        )
 
-    def _get_after_all_stage(self, plan: EvaluatablePlan) -> t.Optional[AfterAllStage]:
+    def _get_after_all_stage(
+        self, plan: EvaluatablePlan, snapshots_by_name: t.Dict[str, Snapshot]
+    ) -> t.Optional[AfterAllStage]:
         after_all = [
-            statement
+            environment_statements
             for environment_statements in plan.environment_statements or []
-            for statement in environment_statements.after_all
+            if environment_statements.after_all
         ]
-        return AfterAllStage(statements=after_all) if after_all else None
+        return (
+            AfterAllStage(statements=after_all, all_snapshots=snapshots_by_name)
+            if after_all
+            else None
+        )
 
     def _get_restatement_stage(
         self, plan: EvaluatablePlan, snapshots_by_name: t.Dict[str, Snapshot]
@@ -220,7 +410,9 @@ class PlanStagesBuilder:
             snapshot_intervals_to_restate[restated_snapshot.table_info] = interval
         if not snapshot_intervals_to_restate or plan.is_dev:
             return None
-        return RestatementStage(snapshot_intervals=snapshot_intervals_to_restate)
+        return RestatementStage(
+            snapshot_intervals=snapshot_intervals_to_restate, all_snapshots=snapshots_by_name
+        )
 
     def _get_physical_layer_update_stage(
         self,
@@ -229,50 +421,80 @@ class PlanStagesBuilder:
         snapshots_to_intervals: SnapshotToIntervals,
         deployability_index: DeployabilityIndex,
     ) -> PhysicalLayerUpdateStage:
-        snapshots_to_create = [
-            s
-            for s in get_snapshots_to_create(plan, snapshots)
-            if s in snapshots_to_intervals and s.is_model and not s.is_symbolic
-        ]
         return PhysicalLayerUpdateStage(
-            snapshots=snapshots_to_create,
+            snapshots=self._get_snapshots_to_create(plan, snapshots),
+            all_snapshots=snapshots,
+            snapshots_with_missing_intervals={s.snapshot_id for s in snapshots_to_intervals},
             deployability_index=deployability_index,
         )
 
     def _get_virtual_layer_update_stage(
-        self, plan: EvaluatablePlan, deployability_index: DeployabilityIndex
+        self,
+        promoted_snapshots: t.Set[SnapshotTableInfo],
+        demoted_snapshots: t.Set[SnapshotTableInfo],
+        demoted_environment_naming_info: t.Optional[EnvironmentNamingInfo],
+        all_snapshots: t.Dict[SnapshotId, Snapshot],
+        deployability_index: DeployabilityIndex,
     ) -> t.Optional[VirtualLayerUpdateStage]:
-        promoted_snapshots, demoted_snapshots = self._get_promoted_demoted_snapshots(plan)
+        promoted_snapshots = {s for s in promoted_snapshots if s.is_model and not s.is_symbolic}
+        demoted_snapshots = {s for s in demoted_snapshots if s.is_model and not s.is_symbolic}
         if not promoted_snapshots and not demoted_snapshots:
             return None
         return VirtualLayerUpdateStage(
             promoted_snapshots=promoted_snapshots,
             demoted_snapshots=demoted_snapshots,
+            demoted_environment_naming_info=demoted_environment_naming_info,
+            all_snapshots=all_snapshots,
             deployability_index=deployability_index,
         )
 
     def _get_promoted_demoted_snapshots(
         self, plan: EvaluatablePlan
-    ) -> t.Tuple[t.Set[SnapshotTableInfo], t.Set[SnapshotTableInfo]]:
+    ) -> t.Tuple[
+        t.Set[SnapshotTableInfo], t.Set[SnapshotTableInfo], t.Optional[EnvironmentNamingInfo]
+    ]:
         existing_environment = self.state_reader.get_environment(plan.environment.name)
         if existing_environment:
-            snapshots_by_name = {s.name: s for s in existing_environment.snapshots}
-            demoted_snapshot_names = {s.name for s in existing_environment.promoted_snapshots} - {
+            new_table_infos = {
+                table_info.name: table_info for table_info in plan.environment.promoted_snapshots
+            }
+            existing_table_infos = {
+                table_info.name: table_info
+                for table_info in existing_environment.promoted_snapshots
+            }
+            views_that_changed_location = {
+                existing_table_info
+                for existing_table_info in existing_environment.promoted_snapshots
+                if existing_table_info.name in new_table_infos
+                and existing_table_info.qualified_view_name.for_environment(
+                    existing_environment.naming_info
+                )
+                != new_table_infos[existing_table_info.name].qualified_view_name.for_environment(
+                    plan.environment.naming_info
+                )
+            }
+            missing_model_names = set(existing_table_infos) - {
                 s.name for s in plan.environment.promoted_snapshots
             }
-            demoted_snapshots = {snapshots_by_name[name] for name in demoted_snapshot_names}
+            demoted_snapshots = {
+                existing_table_infos[name] for name in missing_model_names
+            } | views_that_changed_location
         else:
             demoted_snapshots = set()
+
         promoted_snapshots = set(plan.environment.promoted_snapshots)
         if existing_environment and plan.environment.can_partially_promote(existing_environment):
             promoted_snapshots -= set(existing_environment.promoted_snapshots)
 
-        def _snapshot_filter(snapshot: SnapshotTableInfo) -> bool:
-            return snapshot.is_model and not snapshot.is_symbolic
+        demoted_environment_naming_info = (
+            existing_environment.naming_info if demoted_snapshots and existing_environment else None
+        )
 
-        return {s for s in promoted_snapshots if _snapshot_filter(s)}, {
-            s for s in demoted_snapshots if _snapshot_filter(s)
-        }
+        return (
+            promoted_snapshots,
+            demoted_snapshots,
+            demoted_environment_naming_info,
+        )
 
     def _missing_intervals(
         self,
@@ -294,6 +516,69 @@ class PlanStagesBuilder:
             interval_end_per_model=plan.interval_end_per_model,
         )
 
+    def _get_audit_only_snapshots(
+        self, new_snapshots: t.Dict[SnapshotId, Snapshot]
+    ) -> t.Dict[SnapshotId, Snapshot]:
+        metadata_snapshots = []
+        for snapshot in new_snapshots.values():
+            if not snapshot.is_metadata or not snapshot.is_model or not snapshot.evaluatable:
+                continue
+
+            metadata_snapshots.append(snapshot)
+
+        # Bulk load all the previous snapshots
+        previous_snapshots = self.state_reader.get_snapshots(
+            [
+                s.previous_version.snapshot_id(s.name)
+                for s in metadata_snapshots
+                if s.previous_version
+            ]
+        ).values()
+
+        # Check if any of the snapshots have modifications to the audits field by comparing the hashes
+        audit_snapshots = {}
+        for snapshot, previous_snapshot in zip(metadata_snapshots, previous_snapshots):
+            new_audits_hash = snapshot.model.audit_metadata_hash()
+            previous_audit_hash = previous_snapshot.model.audit_metadata_hash()
+
+            if snapshot.model.audits and previous_audit_hash != new_audits_hash:
+                audit_snapshots[snapshot.snapshot_id] = snapshot
+
+        return audit_snapshots
+
+    def _get_snapshots_to_create(
+        self, plan: EvaluatablePlan, snapshots: t.Dict[SnapshotId, Snapshot]
+    ) -> t.List[Snapshot]:
+        promoted_snapshot_ids = (
+            set(plan.environment.promoted_snapshot_ids)
+            if plan.environment.promoted_snapshot_ids is not None
+            else None
+        )
+
+        def _should_create(s: Snapshot) -> bool:
+            if not s.is_model or s.is_symbolic:
+                return False
+            # Only create tables for snapshots that we're planning to promote or that were selected for backfill
+            return (
+                plan.is_selected_for_backfill(s.name)
+                or promoted_snapshot_ids is None
+                or s.snapshot_id in promoted_snapshot_ids
+            )
+
+        return [s for s in snapshots.values() if _should_create(s)]
+
+    def _adjust_intervals(
+        self, snapshots_by_name: t.Dict[str, Snapshot], plan: EvaluatablePlan
+    ) -> None:
+        # Make sure the intervals are up to date and restatements are reflected
+        self.state_reader.refresh_snapshot_intervals(snapshots_by_name.values())
+        for new_snapshot in plan.new_snapshots:
+            if new_snapshot.is_forward_only:
+                # Forward-only snapshots inherit intervals in dev because of cloning
+                new_snapshot.dev_intervals = new_snapshot.intervals.copy()
+        for s_name, interval in plan.restatements.items():
+            snapshots_by_name[s_name].remove_interval(interval)
+
 
 def build_plan_stages(
     plan: EvaluatablePlan,