Revert VeryVerbose output in favour of simplicity

Author: erindru

sqlmesh/core/console.py

@@ -2031,7 +2031,7 @@ def _prompt_categorize(
             if plan.selected_models_to_restate:
                 # There were legitimate restatements, no dev previews
                 tree = Tree(
-                    "[bold]Models selected for restatement[/bold]\n"
+                    "[bold]Models selected for restatement:[/bold]\n"
                     "This causes backfill of the model itself as well as affected downstream models"
                 )
                 model_fqn_to_snapshot = {s.name: s for s in plan.snapshots.values()}

sqlmesh/core/plan/explainer.py

@@ -24,7 +24,6 @@
 )
 from sqlmesh.core.state_sync import StateReader
 from sqlmesh.core.snapshot.definition import (
-    Snapshot,
     SnapshotInfoMixin,
     SnapshotNameVersionLike,
 )
@@ -59,12 +58,7 @@ def evaluate(
 
         # add extra metadata that's only needed at this point for better --explain output
         plan_stages = [
-            ExplainableRestatementStage.from_restatement_stage(
-                stage,
-                self.state_reader,
-                plan,
-                fetch_full_snapshots=explainer_console.verbosity.is_very_verbose,
-            )
+            ExplainableRestatementStage.from_restatement_stage(stage, self.state_reader, plan)
             if isinstance(stage, stages.RestatementStage)
             else stage
             for stage in plan_stages
@@ -78,11 +72,6 @@ class ExplainerConsole(abc.ABC):
     def explain(self, stages: t.List[stages.PlanStage]) -> None:
         pass
 
-    @property
-    @abc.abstractmethod
-    def verbosity(self) -> Verbosity:
-        pass
-
 
 @dataclass
 class ExplainableRestatementStage(stages.RestatementStage):
@@ -91,9 +80,7 @@ class ExplainableRestatementStage(stages.RestatementStage):
     of what might happen when they ask for the plan to be explained
     """
 
-    snapshot_intervals_to_clear: t.Dict[
-        str, t.List[t.Tuple[t.Optional[Snapshot], SnapshotIntervalClearRequest]]
-    ]
+    snapshot_intervals_to_clear: t.Dict[str, t.List[SnapshotIntervalClearRequest]]
     """Which snapshots from other environments would have intervals cleared as part of restatement, grouped by name."""
 
     @classmethod
@@ -102,7 +89,6 @@ def from_restatement_stage(
         stage: stages.RestatementStage,
         state_reader: StateReader,
         plan: EvaluatablePlan,
-        fetch_full_snapshots: bool = False,
     ) -> ExplainableRestatementStage:
         loaded_snapshots = {s.snapshot_id: s for s in stage.all_snapshots.values()}
 
@@ -113,21 +99,10 @@ def from_restatement_stage(
             loaded_snapshots=loaded_snapshots,
         )
 
-        if fetch_full_snapshots:
-            # extend loaded_snapshots with the remaining full Snapshot objects from all_restatement_intervals
-            # so that we can generate physical table names for them while explaining what's going on
-            remaining_snapshot_ids_to_load = set(all_restatement_intervals).difference(
-                loaded_snapshots
-            )
-            loaded_snapshots.update(
-                state_reader.get_snapshots(snapshot_ids=remaining_snapshot_ids_to_load)
-            )
-
+        # Group the interval clear requests by snapshot name to make them easier to write to the console
         snapshot_intervals_to_clear = defaultdict(list)
-        for snapshot_id, clear_request in all_restatement_intervals.items():
-            snapshot_intervals_to_clear[clear_request.snapshot.name].append(
-                (loaded_snapshots.get(snapshot_id), clear_request)
-            )
+        for _, clear_request in all_restatement_intervals.items():
+            snapshot_intervals_to_clear[clear_request.snapshot.name].append(clear_request)
 
         return cls(
             snapshot_intervals_to_clear=snapshot_intervals_to_clear,
@@ -150,13 +125,9 @@ def __init__(
         self.environment_naming_info = environment_naming_info
         self.dialect = dialect
         self.default_catalog = default_catalog
-        self._verbosity = verbosity
+        self.verbosity = verbosity
         self.console: RichConsole = console or srich.console
 
-    @property
-    def verbosity(self) -> Verbosity:
-        return self._verbosity
-
     def explain(self, stages: t.List[stages.PlanStage]) -> None:
         tree = Tree("[bold]Explained plan[/bold]")
         for stage in stages:
@@ -246,50 +217,21 @@ def visit_restatement_stage(
             snapshot_intervals := stage.snapshot_intervals_to_clear
         ):
             for name, requests in snapshot_intervals.items():
-                if not requests:
-                    # ensure that there is at least one SnapshotIntervalClearRequest in the list
-                    continue
-
                 display_name = model_display_name(
                     name, self.environment_naming_info, self.default_catalog, self.dialect
                 )
-                _, clear_request = requests[0]
-                interval_start, interval_end = clear_request.interval
+                interval_start = min(cr.interval[0] for cr in requests)
+                interval_end = max(cr.interval[1] for cr in requests)
+
+                if not interval_start or not interval_end:
+                    continue
+
                 node = tree.add(f"{display_name} [{to_ts(interval_start)} - {to_ts(interval_end)}]")
 
-                if not self.verbosity.is_very_verbose:
-                    # In normal mode we just indicate which environments are affected at a high level
-                    all_environment_names = sorted(
-                        set(env_name for (_, cr) in requests for env_name in cr.environment_names)
-                    )
-                    node.add("in environments: " + ", ".join(all_environment_names))
-                else:
-                    # In "very verbose" mode, we print all the affected physical tables
-
-                    # group by environment for the console output
-                    by_environment: t.Dict[t.Optional[str], t.List[Snapshot]] = defaultdict(list)
-
-                    for snapshot, clear_request in requests:
-                        if not snapshot:
-                            # This check is mostly for mypy, snapshots should have been loaded
-                            # while creating the ExplainableRestatementStage if the verbosity was set to VERY_VERBOSE
-                            continue
-                        if clear_request.sorted_environment_names:
-                            # snapshot is promoted in these environments
-                            for env in clear_request.sorted_environment_names:
-                                by_environment[env].append(snapshot)
-                        else:
-                            # snapshot is not currently promoted in any environment
-                            by_environment[None].append(snapshot)
-
-                    for env_name, snapshots_to_clear in by_environment.items():
-                        env_name = env_name or "(no env)"
-                        for snapshot in snapshots_to_clear:
-                            # note: we dont need a DeployabilityIndex and can just hardcode is_deployable=True.
-                            # The reason is that non-deployable data can never be restated so we only need to
-                            # bother clearing intervals for the deployable version of the table
-                            physical_table_name = snapshot.table_name(True)
-                            node.add(f"{env_name} -> {physical_table_name}")
+                all_environment_names = sorted(
+                    set(env_name for cr in requests for env_name in cr.environment_names)
+                )
+                node.add("in environments: " + ", ".join(all_environment_names))
 
         return tree
 

tests/core/test_plan_stages.py

@@ -765,19 +765,17 @@ def _get_snapshots(snapshot_ids: t.Iterable[SnapshotIdLike]):
     restatement_stage = stages[2]
     assert isinstance(restatement_stage, RestatementStage)
     restatement_stage = ExplainableRestatementStage.from_restatement_stage(
-        restatement_stage, state_reader, plan, fetch_full_snapshots=True
+        restatement_stage, state_reader, plan
     )
 
     # note: we only clear the intervals from state for "a" in dev, we leave prod alone
     assert restatement_stage.snapshot_intervals_to_clear
     assert len(restatement_stage.snapshot_intervals_to_clear) == 1
     snapshot_name, clear_requests = list(restatement_stage.snapshot_intervals_to_clear.items())[0]
+    assert snapshot_name == '"a"'
     assert len(clear_requests) == 1
-    full_snapshot, clear_request = clear_requests[0]
-    assert full_snapshot is not None
+    clear_request = clear_requests[0]
     assert isinstance(clear_request, SnapshotIntervalClearRequest)
-    assert snapshot_name == '"a"'
-    assert full_snapshot.name == snapshot_name
     assert clear_request.snapshot_id == snapshot_a_dev.snapshot_id
     assert clear_request.snapshot == snapshot_a_dev.id_and_version
     assert clear_request.interval == (to_timestamp("2023-01-01"), to_timestamp("2023-01-02"))