sqlmesh 0.188.2.dev30__py3-none-any.whl → 0.188.2.dev31__py3-none-any.whl

sqlmesh/_version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.188.2.dev30'
-__version_tuple__ = version_tuple = (0, 188, 2, 'dev30')
+__version__ = version = '0.188.2.dev31'
+__version_tuple__ = version_tuple = (0, 188, 2, 'dev31')

sqlmesh/cli/main.py

@@ -457,7 +457,13 @@ def diff(ctx: click.Context, environment: t.Optional[str] = None) -> None:
 @click.option(
     "--diff-rendered",
     is_flag=True,
-    help="Output text differences for the rendered versions of the models and standalone audits",
+    help="Output text differences for the rendered versions of the models and standalone audits.",
+    default=None,
+)
+@click.option(
+    "--explain",
+    is_flag=True,
+    help="Explain the plan instead of applying it.",
     default=None,
 )
 @opt.verbose

sqlmesh/core/context.py

@@ -88,7 +88,7 @@ from sqlmesh.core.notification_target import (
     NotificationTarget,
     NotificationTargetManager,
 )
-from sqlmesh.core.plan import Plan, PlanBuilder, SnapshotIntervals
+from sqlmesh.core.plan import Plan, PlanBuilder, SnapshotIntervals, PlanExplainer
 from sqlmesh.core.plan.definition import UserProvidedFlags
 from sqlmesh.core.reference import ReferenceGraph
 from sqlmesh.core.scheduler import Scheduler, CompletionStatus
@@ -1211,6 +1211,7 @@ class GenericContext(BaseContext, t.Generic[C]):
         run: t.Optional[bool] = None,
         diff_rendered: t.Optional[bool] = None,
         skip_linter: t.Optional[bool] = None,
+        explain: t.Optional[bool] = None,
     ) -> Plan:
         """Interactively creates a plan.
 
@@ -1256,6 +1257,7 @@ class GenericContext(BaseContext, t.Generic[C]):
             run: Whether to run latest intervals as part of the plan application.
             diff_rendered: Whether the diff should compare raw vs rendered models
             skip_linter: Linter runs by default so this will skip it if enabled
+            explain: Whether to explain the plan instead of applying it.
 
         Returns:
             The populated Plan object.
@@ -1283,6 +1285,7 @@ class GenericContext(BaseContext, t.Generic[C]):
             run=run,
             diff_rendered=diff_rendered,
             skip_linter=skip_linter,
+            explain=explain,
         )
 
         plan = plan_builder.build()
@@ -1292,6 +1295,9 @@ class GenericContext(BaseContext, t.Generic[C]):
             # or if there are any uncategorized snapshots in the plan
             no_prompts = False
 
+        if explain:
+            auto_apply = True
+
         self.console.plan(
             plan_builder,
             auto_apply if auto_apply is not None else self.config.plan.auto_apply,
@@ -1328,6 +1334,7 @@ class GenericContext(BaseContext, t.Generic[C]):
         run: t.Optional[bool] = None,
         diff_rendered: t.Optional[bool] = None,
         skip_linter: t.Optional[bool] = None,
+        explain: t.Optional[bool] = None,
     ) -> PlanBuilder:
         """Creates a plan builder.
 
@@ -1544,6 +1551,7 @@ class GenericContext(BaseContext, t.Generic[C]):
             interval_end_per_model=max_interval_end_per_model,
             console=self.console,
             user_provided_flags=user_provided_flags,
+            explain=explain or False,
         )
 
     def apply(
@@ -1568,6 +1576,16 @@ class GenericContext(BaseContext, t.Generic[C]):
             return
         if plan.uncategorized:
             raise UncategorizedPlanError("Can't apply a plan with uncategorized changes.")
+
+        if plan.explain:
+            explainer = PlanExplainer(
+                state_reader=self.state_reader,
+                default_catalog=self.default_catalog,
+                console=self.console,
+            )
+            explainer.evaluate(plan.to_evaluatable())
+            return
+
         self.notification_target_manager.notify(
             NotificationEvent.APPLY_START,
             environment=plan.environment_naming_info.name,

sqlmesh/core/environment.py

@@ -229,6 +229,19 @@ class Environment(EnvironmentNamingInfo, EnvironmentSummary):
             finalized_ts=self.finalized_ts,
         )
 
+    def can_partially_promote(self, existing_environment: Environment) -> bool:
+        """Returns True if the existing environment can be partially promoted to the current environment.
+
+        Partial promotion means that we don't need to re-create views for snapshots that are already promoted in the
+        target environment.
+        """
+        return (
+            bool(existing_environment.finalized_ts)
+            and not existing_environment.expired
+            and existing_environment.gateway_managed == self.gateway_managed
+            and existing_environment.name == c.PROD
+        )
+
     def _convert_list_to_models_and_store(
         self, field: str, type_: t.Type[PydanticType]
     ) -> t.Optional[t.List[PydanticType]]:

sqlmesh/core/plan/__init__.py

@@ -10,3 +10,4 @@ from sqlmesh.core.plan.evaluator import (
     PlanEvaluator as PlanEvaluator,
     update_intervals_for_new_snapshots as update_intervals_for_new_snapshots,
 )
+from sqlmesh.core.plan.explainer import PlanExplainer as PlanExplainer

sqlmesh/core/plan/builder.py

@@ -83,6 +83,7 @@ class PlanBuilder:
             environment state, or to use whatever snapshots are in the current environment state even if
             the environment is not finalized.
         interval_end_per_model: The mapping from model FQNs to target end dates.
+        explain: Whether to explain the plan instead of applying it.
     """
 
     def __init__(
@@ -112,6 +113,7 @@ class PlanBuilder:
         enable_preview: bool = False,
         end_bounded: bool = False,
         ensure_finalized_snapshots: bool = False,
+        explain: bool = False,
         interval_end_per_model: t.Optional[t.Dict[str, int]] = None,
         console: t.Optional[PlanBuilderConsole] = None,
         user_provided_flags: t.Optional[t.Dict[str, UserProvidedFlags]] = None,
@@ -142,6 +144,7 @@ class PlanBuilder:
         self._console = console or get_console()
         self._choices: t.Dict[SnapshotId, SnapshotChangeCategory] = {}
         self._user_provided_flags = user_provided_flags
+        self._explain = explain
 
         self._start = start
         if not self._start and (
@@ -273,6 +276,7 @@ class PlanBuilder:
             empty_backfill=self._empty_backfill,
             no_gaps=self._no_gaps,
             forward_only=self._forward_only,
+            explain=self._explain,
             allow_destructive_models=t.cast(t.Set, self._allow_destructive_models),
             include_unmodified=self._include_unmodified,
             environment_ttl=self._environment_ttl,

sqlmesh/core/plan/definition.py

@@ -46,6 +46,7 @@ class Plan(PydanticModel, frozen=True):
     include_unmodified: bool
     end_bounded: bool
     ensure_finalized_snapshots: bool
+    explain: bool
 
     environment_ttl: t.Optional[str] = None
     environment_naming_info: EnvironmentNamingInfo

sqlmesh/core/plan/evaluator.py

@@ -36,7 +36,7 @@ from sqlmesh.core.snapshot import (
     SnapshotCreationFailedError,
 )
 from sqlmesh.utils import CompletionStatus
-from sqlmesh.core.state_sync import StateSync
+from sqlmesh.core.state_sync import StateSync, StateReader
 from sqlmesh.core.state_sync.base import PromotionResult
 from sqlmesh.utils.concurrency import NodeExecutionFailedError
 from sqlmesh.utils.errors import PlanError
@@ -284,23 +284,7 @@ class BuiltInPlanEvaluator(PlanEvaluator):
             new_snapshots=plan.new_snapshots, plan_id=plan.plan_id
         )
 
-        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
-            )
-
-        snapshots_to_create = [s for s in snapshots.values() if _should_create(s)]
+        snapshots_to_create = get_snapshots_to_create(plan, snapshots)
 
         completion_status = None
         progress_stopped = False
@@ -573,32 +557,7 @@ class BuiltInPlanEvaluator(PlanEvaluator):
         plan: EvaluatablePlan,
         new_snapshots: t.Dict[SnapshotId, Snapshot],
     ) -> None:
-        # Filter out snapshots that are not categorized as metadata changes on models
-        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_sync.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
-
+        audit_snapshots = get_audit_only_snapshots(new_snapshots, self.state_sync)
         if not audit_snapshots:
             return
 
@@ -636,3 +595,52 @@ def update_intervals_for_new_snapshots(
 
     if snapshots_intervals:
         state_sync.add_snapshots_intervals(snapshots_intervals)
+
+
+def get_audit_only_snapshots(
+    new_snapshots: t.Dict[SnapshotId, Snapshot], state_reader: StateReader
+) -> 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 = 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(
+    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)]

sqlmesh/core/plan/explainer.py

@@ -0,0 +1,281 @@
+import abc
+import typing as t
+import logging
+
+from rich.console import Console as RichConsole
+from rich.tree import Tree
+from sqlglot.dialects.dialect import DialectType
+from sqlmesh.core import constants as c
+from sqlmesh.core.console import Console, TerminalConsole, get_console
+from sqlmesh.core.environment import EnvironmentNamingInfo
+from sqlmesh.core.plan.definition import EvaluatablePlan, SnapshotIntervals
+from sqlmesh.core.plan import stages
+from sqlmesh.core.plan.evaluator import (
+    PlanEvaluator,
+)
+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.date import to_ts
+from sqlmesh.utils.errors import SQLMeshError
+
+
+logger = logging.getLogger(__name__)
+
+
+class PlanExplainer(PlanEvaluator):
+    def __init__(
+        self,
+        state_reader: StateReader,
+        default_catalog: t.Optional[str],
+        console: t.Optional[Console] = None,
+    ):
+        self.state_reader = state_reader
+        self.default_catalog = default_catalog
+        self.console = console or get_console()
+
+    def evaluate(
+        self, plan: EvaluatablePlan, circuit_breaker: t.Optional[t.Callable[[], bool]] = None
+    ) -> None:
+        plan_stages = stages.build_plan_stages(plan, self.state_reader, self.default_catalog)
+        explainer_console = _get_explainer_console(
+            self.console, plan.environment, self.default_catalog
+        )
+        explainer_console.explain(plan_stages)
+
+
+class ExplainerConsole(abc.ABC):
+    @abc.abstractmethod
+    def explain(self, stages: t.List[stages.PlanStage]) -> None:
+        pass
+
+
+MAX_TREE_LENGTH = 10
+
+
+class RichExplainerConsole(ExplainerConsole):
+    def __init__(
+        self,
+        environment_naming_info: EnvironmentNamingInfo,
+        dialect: DialectType,
+        default_catalog: t.Optional[str],
+        verbosity: Verbosity = Verbosity.DEFAULT,
+        console: t.Optional[RichConsole] = None,
+    ):
+        self.environment_naming_info = environment_naming_info
+        self.dialect = dialect
+        self.default_catalog = default_catalog
+        self.verbosity = verbosity
+        self.console: RichConsole = console or srich.console
+
+    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__)}"
+            if not hasattr(self, handler_name):
+                logger.error("Unexpected stage: %s", stage.__class__.__name__)
+                continue
+            handler = getattr(self, handler_name)
+            result = handler(stage)
+            if result:
+                tree.add(self._limit_tree(result))
+        self.console.print(tree)
+
+    def visit_before_all_stage(self, stage: stages.BeforeAllStage) -> Tree:
+        return Tree("[bold]Execute before all statements[/bold]")
+
+    def visit_after_all_stage(self, stage: stages.AfterAllStage) -> Tree:
+        return Tree("[bold]Execute after all statements[/bold]")
+
+    def visit_physical_layer_update_stage(self, stage: stages.PhysicalLayerUpdateStage) -> Tree:
+        if not stage.snapshots:
+            return Tree("[bold]SKIP: No physical layer updates to perform[/bold]")
+
+        tree = Tree(
+            "[bold]Validate SQL and create physical layer tables and views if they do not exist[/bold]"
+        )
+        for snapshot in stage.snapshots:
+            is_deployable = (
+                stage.deployability_index.is_deployable(snapshot)
+                if self.environment_naming_info.name != c.PROD
+                else True
+            )
+            display_name = self._display_name(snapshot)
+            table_name = snapshot.table_name(is_deployable)
+            model_tree = Tree(f"{display_name} -> {table_name}")
+
+            if snapshot.is_model:
+                if snapshot.model.pre_statements:
+                    model_tree.add("Run pre-statements")
+                if snapshot.model.annotated:
+                    model_tree.add("Dry run model query without inserting results")
+
+            if snapshot.is_view:
+                create_tree = Tree("Create view if it doesn't exist")
+            elif snapshot.is_forward_only and snapshot.previous_versions:
+                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"
+                )
+            else:
+                create_tree = Tree("Create table if it doesn't exist")
+
+            if not is_deployable:
+                create_tree.add("[orange1]preview[/orange1]: data will NOT be reused in production")
+            model_tree.add(create_tree)
+
+            if snapshot.is_model and snapshot.model.post_statements:
+                model_tree.add("Run post-statements")
+
+            tree.add(model_tree)
+        return tree
+
+    def visit_audit_only_run_stage(self, stage: stages.AuditOnlyRunStage) -> Tree:
+        tree = Tree("[bold]Audit-only execution[/bold]")
+        for snapshot in stage.snapshots:
+            display_name = self._display_name(snapshot)
+            tree.add(display_name)
+        return tree
+
+    def visit_restatement_stage(self, stage: stages.RestatementStage) -> Tree:
+        tree = Tree("[bold]Invalidate data intervals as part of restatement[/bold]")
+        for snapshot_table_info, interval in stage.snapshot_intervals.items():
+            display_name = self._display_name(snapshot_table_info)
+            tree.add(f"{display_name} [{to_ts(interval[0])} - {to_ts(interval[1])}]")
+        return tree
+
+    def visit_backfill_stage(self, stage: stages.BackfillStage) -> Tree:
+        if not stage.snapshot_to_intervals:
+            return Tree("[bold]SKIP: No model batches to execute[/bold]")
+
+        tree = Tree(
+            "[bold]Backfill models by running their queries and run standalone audits[/bold]"
+        )
+        for snapshot, intervals in stage.snapshot_to_intervals.items():
+            display_name = self._display_name(snapshot)
+            if snapshot.is_model:
+                table_name = snapshot.table_name(stage.deployability_index.is_deployable(snapshot))
+                model_tree = Tree(f"{display_name} -> {table_name}")
+
+                for signal_name, _ in snapshot.model.signals:
+                    model_tree.add(f"Check '{signal_name}' signal")
+
+                if snapshot.model.pre_statements:
+                    model_tree.add("Run pre-statements")
+
+                if snapshot.is_incremental:
+                    current_intervals = (
+                        snapshot.intervals
+                        if stage.deployability_index.is_deployable(snapshot)
+                        else snapshot.dev_intervals
+                    )
+                    if current_intervals:
+                        formatted_range = SnapshotIntervals(
+                            snapshot_id=snapshot.snapshot_id, intervals=intervals
+                        ).format_intervals(snapshot.node.interval_unit)
+                        model_tree.add(
+                            f"Incrementally insert records within the range [{formatted_range}]"
+                        )
+                    else:
+                        # If there are no intervals, the table will be fully refreshed
+                        model_tree.add("Fully refresh table")
+                elif snapshot.is_view:
+                    model_tree.add("Recreate view")
+                else:
+                    model_tree.add("Fully refresh table")
+
+                if snapshot.model.post_statements:
+                    model_tree.add("Run post-statements")
+
+                if snapshot.model.audits:
+                    for audit_name, _ in snapshot.model.audits:
+                        model_tree.add(f"Run '{audit_name}' audit")
+
+                tree.add(model_tree)
+            else:
+                tree.add(f"{display_name} \[standalone audit]")
+        return tree
+
+    def visit_migrate_schemas_stage(self, stage: stages.MigrateSchemasStage) -> Tree:
+        tree = Tree(
+            "[bold]Update schemas (add, drop, alter columns) of production physical tables to reflect forward-only changes[/bold]"
+        )
+        for snapshot in stage.snapshots:
+            display_name = self._display_name(snapshot)
+            table_name = snapshot.table_name(True)
+            tree.add(f"{display_name} -> {table_name}")
+        return tree
+
+    def visit_virtual_layer_update_stage(self, stage: stages.VirtualLayerUpdateStage) -> Tree:
+        tree = Tree(
+            f"[bold]Update the virtual layer for environment '{self.environment_naming_info.name}'[/bold]"
+        )
+        promote_tree = Tree(
+            "[bold]Create or update views in the virtual layer to point at new physical tables and views[/bold]"
+        )
+        for snapshot in stage.promoted_snapshots:
+            display_name = self._display_name(snapshot)
+            table_name = snapshot.table_name(stage.deployability_index.is_representative(snapshot))
+            promote_tree.add(f"{display_name} -> {table_name}")
+
+        demote_tree = Tree(
+            "[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)
+            demote_tree.add(display_name)
+
+        if stage.promoted_snapshots:
+            tree.add(self._limit_tree(promote_tree))
+        if stage.demoted_snapshots:
+            tree.add(self._limit_tree(demote_tree))
+        return tree
+
+    def visit_environment_record_update_stage(
+        self, stage: stages.EnvironmentRecordUpdateStage
+    ) -> t.Optional[Tree]:
+        return None
+
+    def _display_name(self, snapshot: SnapshotInfoMixin) -> str:
+        return snapshot.display_name(
+            self.environment_naming_info,
+            self.default_catalog if self.verbosity < Verbosity.VERY_VERBOSE else None,
+            dialect=self.dialect,
+        )
+
+    def _limit_tree(self, tree: Tree) -> Tree:
+        tree_length = len(tree.children)
+        if tree_length <= MAX_TREE_LENGTH:
+            return tree
+        if self.verbosity < Verbosity.VERY_VERBOSE:
+            tree.children = [
+                tree.children[0],
+                Tree(f".... {tree_length - 2} more ...."),
+                tree.children[-1],
+            ]
+        return tree
+
+
+def _get_explainer_console(
+    console: t.Optional[Console],
+    environment_naming_info: EnvironmentNamingInfo,
+    default_catalog: t.Optional[str],
+) -> ExplainerConsole:
+    console = console or get_console()
+    if not isinstance(console, TerminalConsole):
+        raise SQLMeshError("Plain explaination is only supported in the terminal.")
+    return RichExplainerConsole(
+        environment_naming_info=environment_naming_info,
+        dialect=console.dialect,
+        default_catalog=default_catalog,
+        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

@@ -0,0 +1,303 @@
+import typing as t
+
+from dataclasses import dataclass
+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 (
+    DeployabilityIndex,
+    Snapshot,
+    SnapshotTableInfo,
+    SnapshotId,
+    Interval,
+)
+
+
+@dataclass
+class BeforeAllStage:
+    statements: t.List[str]
+
+
+@dataclass
+class AfterAllStage:
+    statements: t.List[str]
+
+
+@dataclass
+class PhysicalLayerUpdateStage:
+    snapshots: t.List[Snapshot]
+    deployability_index: DeployabilityIndex
+
+
+@dataclass
+class AuditOnlyRunStage:
+    snapshots: t.List[Snapshot]
+
+
+@dataclass
+class RestatementStage:
+    snapshot_intervals: t.Dict[SnapshotTableInfo, Interval]
+
+
+@dataclass
+class BackfillStage:
+    snapshot_to_intervals: SnapshotToIntervals
+    deployability_index: DeployabilityIndex
+    before_promote: bool = True
+
+
+@dataclass
+class MigrateSchemasStage:
+    snapshots: t.List[Snapshot]
+
+
+@dataclass
+class VirtualLayerUpdateStage:
+    promoted_snapshots: t.Set[SnapshotTableInfo]
+    demoted_snapshots: t.Set[SnapshotTableInfo]
+    deployability_index: DeployabilityIndex
+
+
+@dataclass
+class EnvironmentRecordUpdateStage:
+    pass
+
+
+PlanStage = t.Union[
+    BeforeAllStage,
+    AfterAllStage,
+    PhysicalLayerUpdateStage,
+    AuditOnlyRunStage,
+    RestatementStage,
+    BackfillStage,
+    MigrateSchemasStage,
+    VirtualLayerUpdateStage,
+    EnvironmentRecordUpdateStage,
+]
+
+
+class PlanStagesBuilder:
+    def __init__(
+        self,
+        state_reader: StateReader,
+        default_catalog: t.Optional[str],
+    ):
+        self.state_reader = state_reader
+        self.default_catalog = default_catalog
+
+    def build(self, plan: EvaluatablePlan) -> t.List[PlanStage]:
+        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}
+        snapshots_by_name = {s.name: s for s in snapshots.values()}
+
+        all_selected_for_backfill_snapshots = {
+            s.snapshot_id for s in snapshots.values() if plan.is_selected_for_backfill(s.name)
+        }
+
+        deployability_index = DeployabilityIndex.create(snapshots, start=plan.start)
+        deployability_index_for_creation = deployability_index
+        if plan.is_dev:
+            before_promote_snapshots = all_selected_for_backfill_snapshots
+            after_promote_snapshots = set()
+            snapshots_with_schema_migration = []
+        else:
+            before_promote_snapshots = {
+                s.snapshot_id
+                for s in snapshots.values()
+                if deployability_index.is_representative(s)
+                and plan.is_selected_for_backfill(s.name)
+            }
+            after_promote_snapshots = all_selected_for_backfill_snapshots - before_promote_snapshots
+            deployability_index = DeployabilityIndex.all_deployable()
+
+            snapshots_with_schema_migration = [
+                s
+                for s in snapshots.values()
+                if s.is_paused
+                and s.is_materialized
+                and not deployability_index_for_creation.is_representative(s)
+            ]
+
+        snapshots_to_intervals = self._missing_intervals(
+            plan, snapshots_by_name, deployability_index
+        )
+        needs_backfill = (
+            not plan.empty_backfill and not plan.skip_backfill and bool(snapshots_to_intervals)
+        )
+        missing_intervals_before_promote: SnapshotToIntervals = {}
+        missing_intervals_after_promote: SnapshotToIntervals = {}
+        if needs_backfill:
+            for snapshot, intervals in snapshots_to_intervals.items():
+                if snapshot.snapshot_id in before_promote_snapshots:
+                    missing_intervals_before_promote[snapshot] = intervals
+                elif snapshot.snapshot_id in after_promote_snapshots:
+                    missing_intervals_after_promote[snapshot] = intervals
+
+        stages: t.List[PlanStage] = []
+
+        before_all_stage = self._get_before_all_stage(plan)
+        if before_all_stage:
+            stages.append(before_all_stage)
+
+        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)
+        if audit_only_snapshots:
+            stages.append(AuditOnlyRunStage(snapshots=list(audit_only_snapshots.values())))
+
+        restatement_stage = self._get_restatement_stage(plan, snapshots_by_name)
+        if restatement_stage:
+            stages.append(restatement_stage)
+
+        if missing_intervals_before_promote:
+            stages.append(
+                BackfillStage(
+                    snapshot_to_intervals=missing_intervals_before_promote,
+                    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)
+            )
+
+        stages.append(EnvironmentRecordUpdateStage())
+
+        if snapshots_with_schema_migration:
+            stages.append(MigrateSchemasStage(snapshots=snapshots_with_schema_migration))
+
+        if missing_intervals_after_promote:
+            stages.append(
+                BackfillStage(
+                    snapshot_to_intervals=missing_intervals_after_promote,
+                    deployability_index=deployability_index,
+                )
+            )
+
+        virtual_layer_update_stage = self._get_virtual_layer_update_stage(plan, deployability_index)
+        if virtual_layer_update_stage:
+            stages.append(virtual_layer_update_stage)
+
+        after_all_stage = self._get_after_all_stage(plan)
+        if after_all_stage:
+            stages.append(after_all_stage)
+
+        return stages
+
+    def _get_before_all_stage(self, plan: EvaluatablePlan) -> t.Optional[BeforeAllStage]:
+        before_all = [
+            statement
+            for environment_statements in plan.environment_statements or []
+            for statement in environment_statements.before_all
+        ]
+        return BeforeAllStage(statements=before_all) if before_all else None
+
+    def _get_after_all_stage(self, plan: EvaluatablePlan) -> t.Optional[AfterAllStage]:
+        after_all = [
+            statement
+            for environment_statements in plan.environment_statements or []
+            for statement in environment_statements.after_all
+        ]
+        return AfterAllStage(statements=after_all) if after_all else None
+
+    def _get_restatement_stage(
+        self, plan: EvaluatablePlan, snapshots_by_name: t.Dict[str, Snapshot]
+    ) -> t.Optional[RestatementStage]:
+        snapshot_intervals_to_restate = {}
+        for name, interval in plan.restatements.items():
+            restated_snapshot = snapshots_by_name[name]
+            restated_snapshot.remove_interval(interval)
+            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)
+
+    def _get_physical_layer_update_stage(
+        self,
+        plan: EvaluatablePlan,
+        snapshots: t.Dict[SnapshotId, Snapshot],
+        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,
+            deployability_index=deployability_index,
+        )
+
+    def _get_virtual_layer_update_stage(
+        self, plan: EvaluatablePlan, deployability_index: DeployabilityIndex
+    ) -> t.Optional[VirtualLayerUpdateStage]:
+        promoted_snapshots, demoted_snapshots = self._get_promoted_demoted_snapshots(plan)
+        if not promoted_snapshots and not demoted_snapshots:
+            return None
+        return VirtualLayerUpdateStage(
+            promoted_snapshots=promoted_snapshots,
+            demoted_snapshots=demoted_snapshots,
+            deployability_index=deployability_index,
+        )
+
+    def _get_promoted_demoted_snapshots(
+        self, plan: EvaluatablePlan
+    ) -> t.Tuple[t.Set[SnapshotTableInfo], t.Set[SnapshotTableInfo]]:
+        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} - {
+                s.name for s in plan.environment.promoted_snapshots
+            }
+            demoted_snapshots = {snapshots_by_name[name] for name in demoted_snapshot_names}
+        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
+
+        return {s for s in promoted_snapshots if _snapshot_filter(s)}, {
+            s for s in demoted_snapshots if _snapshot_filter(s)
+        }
+
+    def _missing_intervals(
+        self,
+        plan: EvaluatablePlan,
+        snapshots_by_name: t.Dict[str, Snapshot],
+        deployability_index: DeployabilityIndex,
+    ) -> SnapshotToIntervals:
+        return merged_missing_intervals(
+            snapshots=snapshots_by_name.values(),
+            start=plan.start,
+            end=plan.end,
+            execution_time=plan.execution_time,
+            restatements={
+                snapshots_by_name[name].snapshot_id: interval
+                for name, interval in plan.restatements.items()
+            },
+            deployability_index=deployability_index,
+            end_bounded=plan.end_bounded,
+            interval_end_per_model=plan.interval_end_per_model,
+        )
+
+
+def build_plan_stages(
+    plan: EvaluatablePlan,
+    state_reader: StateReader,
+    default_catalog: t.Optional[str],
+) -> t.List[PlanStage]:
+    return PlanStagesBuilder(state_reader, default_catalog).build(plan)

sqlmesh/core/scheduler.py

@@ -118,16 +118,12 @@ class Scheduler:
                 allow_partials, and other attributes that could cause the intervals to exceed the target end date.
             selected_snapshots: A set of snapshot names to run. If not provided, all snapshots will be run.
         """
-        restatements = restatements or {}
-        validate_date_range(start, end)
-
-        snapshots: t.Collection[Snapshot] = self.snapshot_per_version.values()
-        snapshots_to_intervals = compute_interval_params(
-            snapshots,
-            start=start or earliest_start_date(snapshots),
-            end=end or now_timestamp(),
+        snapshots_to_intervals = merged_missing_intervals(
+            snapshots=self.snapshot_per_version.values(),
+            start=start,
+            end=end,
+            execution_time=execution_time,
             deployability_index=deployability_index,
-            execution_time=execution_time or now_timestamp(),
             restatements=restatements,
             interval_end_per_model=interval_end_per_model,
             ignore_cron=ignore_cron,
@@ -700,6 +696,52 @@ class Scheduler:
         return audit_results
 
 
+def merged_missing_intervals(
+    snapshots: t.Collection[Snapshot],
+    start: t.Optional[TimeLike] = None,
+    end: t.Optional[TimeLike] = None,
+    execution_time: t.Optional[TimeLike] = None,
+    deployability_index: t.Optional[DeployabilityIndex] = None,
+    restatements: t.Optional[t.Dict[SnapshotId, Interval]] = None,
+    interval_end_per_model: t.Optional[t.Dict[str, int]] = None,
+    ignore_cron: bool = False,
+    end_bounded: bool = False,
+) -> SnapshotToIntervals:
+    """Find the largest contiguous date interval parameters based only on what is missing.
+
+    For each node name, find all dependencies and look for a stored snapshot from the metastore. If a snapshot is found,
+    calculate the missing intervals that need to be processed given the passed in start and end intervals.
+
+    This is a superset of what may actually get processed at runtime based on things like batch size, signal readiness, etc.
+
+    Args:
+        snapshots: A set of target snapshots for which intervals should be computed.
+        start: The start of the run. Defaults to the min node start date.
+        end: The end of the run. Defaults to now.
+        execution_time: The date/time reference to use for execution time. Defaults to now.
+        deployability_index: Determines snapshots that are deployable in the context of this evaluation.
+        restatements: A set of snapshot names being restated.
+        interval_end_per_model: The mapping from model FQNs to target end dates.
+        ignore_cron: Whether to ignore the node's cron schedule.
+        end_bounded: If set to true, the returned intervals will be bounded by the target end date, disregarding lookback,
+            allow_partials, and other attributes that could cause the intervals to exceed the target end date.
+    """
+    restatements = restatements or {}
+    validate_date_range(start, end)
+
+    return compute_interval_params(
+        snapshots,
+        start=start or earliest_start_date(snapshots),
+        end=end or now_timestamp(),
+        deployability_index=deployability_index,
+        execution_time=execution_time or now_timestamp(),
+        restatements=restatements,
+        interval_end_per_model=interval_end_per_model,
+        ignore_cron=ignore_cron,
+        end_bounded=end_bounded,
+    )
+
+
 def compute_interval_params(
     snapshots: t.Collection[Snapshot],
     *,

sqlmesh/core/state_sync/db/facade.py

@@ -24,7 +24,6 @@ from datetime import datetime
 
 from sqlglot import exp
 
-from sqlmesh.core import constants as c
 from sqlmesh.core.console import Console, get_console
 from sqlmesh.core.engine_adapter import EngineAdapter
 from sqlmesh.core.environment import Environment, EnvironmentStatements, EnvironmentSummary
@@ -224,13 +223,7 @@ class EngineAdapterStateSync(StateSync):
         }
 
         added_table_infos = set(table_infos.values())
-        if (
-            existing_environment
-            and existing_environment.finalized_ts
-            and not existing_environment.expired
-            and existing_environment.gateway_managed == environment.gateway_managed
-            and existing_environment.name == c.PROD
-        ):
+        if existing_environment and environment.can_partially_promote(existing_environment):
             # Only promote new snapshots.
             added_table_infos -= set(existing_environment.promoted_snapshots)
 

{sqlmesh-0.188.2.dev30.dist-info → sqlmesh-0.188.2.dev31.dist-info}/METADATA

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

{sqlmesh-0.188.2.dev30.dist-info → sqlmesh-0.188.2.dev31.dist-info}/RECORD

@@ -1,5 +1,5 @@
 sqlmesh/__init__.py,sha256=QjwaamJIdW7voXoS880yAx7tHm-Im4_mqGA-XJgafos,7631
-sqlmesh/_version.py,sha256=DU1AIAOe9GaxIAn4LmIG-6XbdsSxIRpDdIhvly6cfeg,530
+sqlmesh/_version.py,sha256=gzm94aWOg0XB5l8YtYf7gt6I9XBNkBbbsBL_cOtPCFo,530
 sqlmesh/magics.py,sha256=fu7-OeT_0_TAkWZOLoiioE3-3iFpvTRxFCbQUlRnfuw,39944
 sqlmesh/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sqlmesh/cicd/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -7,16 +7,16 @@ sqlmesh/cicd/bot.py,sha256=2zlbn-DXkqQzr3lA0__IGU4XaIfXBXBKLWXNI2DRJX8,759
 sqlmesh/cicd/config.py,sha256=mpgkisSBBovlNrNZir2unT8Wes6b38RW2UsU_o4e8vY,109
 sqlmesh/cli/__init__.py,sha256=MAXAyO7isbyM-PaSdFjkJNcjn32WjOl0XzxT5gvp_vo,1690
 sqlmesh/cli/example_project.py,sha256=QAFQbw_kzqn30GLTthqsuWXbFDBpX8W6RsCgQ-jx65M,9308
-sqlmesh/cli/main.py,sha256=dt92CJPuMzUZvBYqXMh-tkUCaLfj2Z5RC2COa98_9Co,32310
+sqlmesh/cli/main.py,sha256=gk2iNJ3trprWtVpqGafbaCubYR3U6ByoacwZGFubRPM,32434
 sqlmesh/cli/options.py,sha256=aC_L5WnMScKzMU55BD1Y-8R-QzqCkPSYrlCI-payHRA,1333
 sqlmesh/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sqlmesh/core/_typing.py,sha256=e1f7xO2aZCy38M_3VoDy-XI3shyd99-IFctgIFSgXWM,497
 sqlmesh/core/console.py,sha256=x7qWETjHgu8ZpMtfW8V3bGKByT4nZXDjgtO6xmvAb-I,151143
 sqlmesh/core/constants.py,sha256=oqt6zjepUhQoWlgapKn_HpG7Pu9mrFwepdX5caNfJUI,2499
-sqlmesh/core/context.py,sha256=ZZskVvTciGvJO6weRzGlrAyQsqRkSqsjCSY2rc_cFZ4,116729
+sqlmesh/core/context.py,sha256=PoqGhpRxIes9Qo59YW_KggqL8Wbcj3rleH8RAQkLHT4,117312
 sqlmesh/core/context_diff.py,sha256=I7luvY2za30E5ynVaFPaEQQEmNViJpWAmW48PGSyDCU,21135
 sqlmesh/core/dialect.py,sha256=93cXYVuNoZ9CvJNTVn2Yz7WDOdHINwVXflbn0eZ-p14,49764
-sqlmesh/core/environment.py,sha256=Fsih6WZ7Tx4ec0XIlmIIspUWcmijPNW5uHPRQSWuhA8,12315
+sqlmesh/core/environment.py,sha256=bNj-JCG_l13dwrp--YPIuGNsuWLTMLcFA5sY8IazVK8,12917
 sqlmesh/core/lineage.py,sha256=zjB0Zfamo2Fja2r5SSZPMbrEKTXr1WjozZPVqvxdybI,3143
 sqlmesh/core/loader.py,sha256=L2pxQZ2OuXnBHcruJW2fsclPIrFyb-TogoWHwm_qKC8,36417
 sqlmesh/core/macros.py,sha256=L_UlI4kysfDiYYpv78kODZw8kYbC9-FdBx7nHm1hBjs,60584
@@ -24,7 +24,7 @@ sqlmesh/core/node.py,sha256=r4_1MRTPcU0MAlwZ5KzrykLT58B7dkKvHzPCsJmEKD8,14497
 sqlmesh/core/notification_target.py,sha256=PPGoDrgbRKxr27vJEu03XqNTQLYTw0ZF_b0yAapxGeI,16158
 sqlmesh/core/reference.py,sha256=k7OSkLqTjPR8WJjNeFj0xAJ297nZUMgb_iTVwKRRKjc,4875
 sqlmesh/core/renderer.py,sha256=KOr7rQ-RfWiS51cEj2fzdhxCrYbU0A5wNTGwKyeqLt4,26636
-sqlmesh/core/scheduler.py,sha256=TB03rSvPyaPMRANOJq_O_cNXvu0fc5rVaDVC9olE5kg,34196
+sqlmesh/core/scheduler.py,sha256=pbSBaKjHwPMW8XIVDChcACv8THSjTPLA_FGwvHKB6rk,36283
 sqlmesh/core/schema_diff.py,sha256=Sp2MoqAngp-yTYevkLaf9jb26SuAdGXoZ54g5MjWowU,30516
 sqlmesh/core/schema_loader.py,sha256=lvrI9k7hr1P4X4E6t3U-KrcuvdQuw0UdNlN90P2s52w,3563
 sqlmesh/core/selector.py,sha256=_hcktUQiKXCPE-mOqXClHUVWBfEZKMPVVNDtpSSRhbI,12660
@@ -92,10 +92,12 @@ sqlmesh/core/model/kind.py,sha256=i6_AMBarXPGPoMdF9kzBkyqS9tu__a2339-BoX7TgCM,36
 sqlmesh/core/model/meta.py,sha256=TRsCztBea2gSknPQxoY1ct13hdWgD0mM9XTHqu5KDgs,21167
 sqlmesh/core/model/schema.py,sha256=OClbAeA8LpW-IiSiLT_TlDWkEqmIIvSk0GXq8SWI-GQ,3443
 sqlmesh/core/model/seed.py,sha256=a0M-1zY1gOkN5ph2GQyataEdBSCtq50YjeFk2LyvInI,5058
-sqlmesh/core/plan/__init__.py,sha256=ctpnu9mK3uTujs0It8qRMqcj9GdObXDnvSgn4rD2zqc,450
-sqlmesh/core/plan/builder.py,sha256=WM-jnBgViLSfnL2-nUdZH9dCkD6TkYUnRuO9TgD8DsQ,38329
-sqlmesh/core/plan/definition.py,sha256=SI3zi2poPkKJKTZogYv60Q7eIOhksaAcFUcu-J2-XqI,13218
-sqlmesh/core/plan/evaluator.py,sha256=RAHJgQoV5Y5SIG_pV2O_Bn0VFlD1yzMC0UrUU6eaB_E,26842
+sqlmesh/core/plan/__init__.py,sha256=aieod5xxcJJl0m7Xp9BXCwwrYnhMbeltGoNZGjwoVTA,521
+sqlmesh/core/plan/builder.py,sha256=mZ64P0m4LDtkyy4NoPsz8gqhtezF8Piaw5aj0_YuTjA,38496
+sqlmesh/core/plan/definition.py,sha256=pBjQu1P5U-XheWOe9WkSNAZeLzYE7LFgYtq6-4Fx67g,13236
+sqlmesh/core/plan/evaluator.py,sha256=7dPtjxc4SuKf9fHsMDwaGsprlXmhcoKi0N6Q1N8eFY4,27009
+sqlmesh/core/plan/explainer.py,sha256=-12__YFHEeKfvcggquZVMFq-Q3DBIy-kMvdyU5j8K5U,11237
+sqlmesh/core/plan/stages.py,sha256=AIBzEji7OorFx9B0Hm50E6h8zWIGSuLkoVWqIhq9AVw,10911
 sqlmesh/core/snapshot/__init__.py,sha256=Z5HTetNCZGoKF1WAKXk4LWL9dc8EC8lwS2O4TtoBmt4,1317
 sqlmesh/core/snapshot/cache.py,sha256=bgqCR2hyf6r2A_8QP1EnXFK25gDX37-Zg0YeMuETWxg,3934
 sqlmesh/core/snapshot/categorizer.py,sha256=qGG5870mu1jR2whKisSBH_GFbsyh96RnzJDgkN7DV9g,2482
@@ -108,7 +110,7 @@ sqlmesh/core/state_sync/common.py,sha256=THK-6AGHFBAuLXydD8QhzmzCdyl0BMrz2rB2xpm
 sqlmesh/core/state_sync/export_import.py,sha256=WJ7sFX2b_RPAFE4yspJRi_4JQnaO23xpJgRxwXD0agA,8709
 sqlmesh/core/state_sync/db/__init__.py,sha256=jGCqKYB7npq4eh6H2LyfBAJWdOP-IFu0DC4CMiQgYvw,107
 sqlmesh/core/state_sync/db/environment.py,sha256=RKaP71CDI7YFhLYuyYVbtyBEWfwvNd2_XsDvjtrQq2Q,13645
-sqlmesh/core/state_sync/db/facade.py,sha256=GOrcJSWeFxLbqf2fuGGLewYCoRhDoXBoLA4AsJ5MixI,25558
+sqlmesh/core/state_sync/db/facade.py,sha256=xCK8zb3mKM3c5Oa8HgId_f2iYzC7Rw5hx5bSfPmGw_g,25319
 sqlmesh/core/state_sync/db/interval.py,sha256=qDo5qX7vulibbg9M8mDA0PjoQQJlUCouBJeWuTuLJ6Y,18043
 sqlmesh/core/state_sync/db/migrator.py,sha256=2LNUwOBNFkA1ntp-Z93S_OWxFQhOBj3ZD_ZqPCyPEAE,18139
 sqlmesh/core/state_sync/db/snapshot.py,sha256=7ccdRxni4UGAul-_15z6-I9GAifC94jfNTvAdUEQ9pw,29480
@@ -270,7 +272,7 @@ sqlmesh/utils/pydantic.py,sha256=I898jAFqa3qU6lG2uPpRebVFncOUo8ZrLWM_R3K3DHU,116
 sqlmesh/utils/rich.py,sha256=xNZyPCqEc4TAlJlsEthg-5eYUWpaizz0QjBzO7a1Yv4,1509
 sqlmesh/utils/windows.py,sha256=r7Yin4WEwbvH7sKA3hOJtRsclmscNuBeCklCfVPvtQs,611
 sqlmesh/utils/yaml.py,sha256=np-WVcwmwsKghCgAj1OBBMsK1SXSRn4wR-H37cGiFr8,2282
-sqlmesh-0.188.2.dev30.dist-info/licenses/LICENSE,sha256=OlMefUjgWJdULtf84BLW0AZZcY8DwdgQqb_1j2862j8,11346
+sqlmesh-0.188.2.dev31.dist-info/licenses/LICENSE,sha256=OlMefUjgWJdULtf84BLW0AZZcY8DwdgQqb_1j2862j8,11346
 web/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 web/client/dist/index.html,sha256=LbR9XrOXE77otBPoDnaomssYz6h2TBwLANs6hUJ0p2M,5472
 web/client/dist/assets/Audits-DB1HcP9M.js,sha256=eGI_Soj69Jntsixw1NqQpdwG94N5jipQZv7T1Y7WUSs,1041
@@ -388,8 +390,8 @@ web/server/api/endpoints/models.py,sha256=ud-lRwriyI_OYg9tZchrBgeiXELiRTLNEodraf
 web/server/api/endpoints/modules.py,sha256=8hqqgonGay_mJmpCw0IdbjsPhWlQH2VLdKAqha-myac,468
 web/server/api/endpoints/plan.py,sha256=OYuQ_4dgbhG9ibTcX1a8mvYgH3ANxw9Fhbb4wg6QWqc,9222
 web/server/api/endpoints/table_diff.py,sha256=SCy3-pr5x6bEEiOaZGCDbiHQhpgxwmnz3Acqa2Ie6jI,2090
-sqlmesh-0.188.2.dev30.dist-info/METADATA,sha256=I3prHMgrH2I8rGoRDnej5HvQgoGCxnCKSQGzluA0UBQ,26541
-sqlmesh-0.188.2.dev30.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-sqlmesh-0.188.2.dev30.dist-info/entry_points.txt,sha256=pIYKtg-u-uO7BK_Y0qrdmfyj0bYrcMc3Xiqr5WE3VFk,121
-sqlmesh-0.188.2.dev30.dist-info/top_level.txt,sha256=bspjo5vjELQkuN0qKuTFIbsrUt3Zeo8D2mlKeHG1LdE,12
-sqlmesh-0.188.2.dev30.dist-info/RECORD,,
+sqlmesh-0.188.2.dev31.dist-info/METADATA,sha256=XR2JL_XCGcYhXBnInxphjWqebJk2X9_KPXtW94Sgjrg,26541
+sqlmesh-0.188.2.dev31.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+sqlmesh-0.188.2.dev31.dist-info/entry_points.txt,sha256=pIYKtg-u-uO7BK_Y0qrdmfyj0bYrcMc3Xiqr5WE3VFk,121
+sqlmesh-0.188.2.dev31.dist-info/top_level.txt,sha256=bspjo5vjELQkuN0qKuTFIbsrUt3Zeo8D2mlKeHG1LdE,12
+sqlmesh-0.188.2.dev31.dist-info/RECORD,,