pr feedback

Author: themisvaltinos

sqlmesh/core/context.py

@@ -1603,28 +1603,6 @@ def plan_builder(
                 execution_time or now(),
             )
 
-            # Validate that the start is not greater than the end date / time
-            effective_start = start or default_start
-            effective_end = end or default_end
-            if effective_start is not None and effective_end is not None:
-                start_ts = to_timestamp(effective_start)
-                end_ts = to_timestamp(effective_end)
-                if start_ts > end_ts:
-                    for model_name in (
-                        set(backfill_models or {})
-                        | set(modified_model_names)
-                        | set(max_interval_end_per_model)
-                    ):
-                        if snapshot := snapshots.get(model_name):
-                            if (
-                                snapshot.node.start is None
-                                or to_timestamp(snapshot.node.start) > end_ts
-                            ):
-                                raise SQLMeshError(
-                                    f"Model '{model_name}': Start date / time ({to_datetime(start_ts)}) can't be greater than end date / time ({to_datetime(end_ts)}).\n"
-                                    f"Set the `start` attribute in your project config model defaults to avoid this issue."
-                                )
-
             # Refresh snapshot intervals to ensure that they are up to date with values reflected in the max_interval_end_per_model.
             self.state_sync.refresh_snapshot_intervals(context_diff.snapshots.values())
 

sqlmesh/core/plan/builder.py

@@ -155,6 +155,7 @@ def __init__(
 
         self._backfill_models = backfill_models
         self._end = end or default_end
+        self._default_start = default_start
         self._apply = apply
         self._console = console or get_console()
         self._choices: t.Dict[SnapshotId, SnapshotChangeCategory] = {}
@@ -802,6 +803,25 @@ def _ensure_valid_date_range(self) -> None:
                     f"Plan end date: '{time_like_to_str(end)}' cannot be in the future (execution time: '{time_like_to_str(self.execution_time)}')"
                 )
 
+        # Validate model-specific start/end dates
+        if (start := self.start or self._default_start) and (end := self.end):
+            start_ts = to_datetime(start)
+            end_ts = to_datetime(end)
+            if start_ts > end_ts:
+                models_to_check: t.Set[str] = (
+                    set(self._backfill_models or [])
+                    | set(self._context_diff.modified_snapshots.keys())
+                    | {s.name for s in self._context_diff.added}
+                    | set((self._end_override_per_model or {}).keys())
+                )
+                for model_name in models_to_check:
+                    if snapshot := self._model_fqn_to_snapshot.get(model_name):
+                        if snapshot.node.start is None or to_datetime(snapshot.node.start) > end_ts:
+                            raise PlanError(
+                                f"Model '{model_name}': Start date / time '({time_like_to_str(start_ts)})' can't be greater than end date / time '({time_like_to_str(end_ts)})'.\n"
+                                f"Set the `start` attribute in your project config model defaults to avoid this issue."
+                            )
+
     def _ensure_no_broken_references(self) -> None:
         for snapshot in self._context_diff.snapshots.values():
             broken_references = {

tests/core/test_context.py

@@ -3059,7 +3059,7 @@ def test_plan_no_start_configured():
 
     # This should raise an error because the model has no start configured and the end time is less than the start time which will be calculated from the intervals
     with pytest.raises(
-        SQLMeshError,
+        PlanError,
         match=r"Model '.*xvg.*': Start date / time .* can't be greater than end date / time .*\.\nSet the `start` attribute in your project config model defaults to avoid this issue",
     ):
         context.plan("dev", execution_time="1999-01-05")