sqlmesh 0.209.1.dev13__py3-none-any.whl → 0.209.1.dev14__py3-none-any.whl

sqlmesh/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.209.1.dev13'
-__version_tuple__ = version_tuple = (0, 209, 1, 'dev13')
+__version__ = version = '0.209.1.dev14'
+__version_tuple__ = version_tuple = (0, 209, 1, 'dev14')
 
 __commit_id__ = commit_id = None

sqlmesh/core/config/common.py

@@ -49,6 +49,35 @@ class EnvironmentSuffixTarget(str, Enum):
         return str(self)
 
 
+class VirtualEnvironmentMode(str, Enum):
+    """Mode for virtual environment behavior.
+
+    FULL: Use full virtual environment functionality with versioned table names and virtual layer updates.
+    DEV_ONLY: Bypass virtual environments in production, using original unversioned model names.
+    """
+
+    FULL = "full"
+    DEV_ONLY = "dev_only"
+
+    @property
+    def is_full(self) -> bool:
+        return self == VirtualEnvironmentMode.FULL
+
+    @property
+    def is_dev_only(self) -> bool:
+        return self == VirtualEnvironmentMode.DEV_ONLY
+
+    @classproperty
+    def default(cls) -> VirtualEnvironmentMode:
+        return VirtualEnvironmentMode.FULL
+
+    def __str__(self) -> str:
+        return self.name
+
+    def __repr__(self) -> str:
+        return str(self)
+
+
 class TableNamingConvention(str, Enum):
     # Causes table names at the physical layer to follow the convention:
     # <schema-name>__<table-name>__<fingerprint>

sqlmesh/core/config/root.py

@@ -14,7 +14,11 @@ from sqlglot.optimizer.normalize_identifiers import normalize_identifiers
 from sqlmesh.cicd.config import CICDBotConfig
 from sqlmesh.core import constants as c
 from sqlmesh.core.console import get_console
-from sqlmesh.core.config import EnvironmentSuffixTarget, TableNamingConvention
+from sqlmesh.core.config.common import (
+    EnvironmentSuffixTarget,
+    TableNamingConvention,
+    VirtualEnvironmentMode,
+)
 from sqlmesh.core.config.base import BaseConfig, UpdateStrategy
 from sqlmesh.core.config.common import variables_validator, compile_regex_mapping
 from sqlmesh.core.config.connection import (
@@ -110,6 +114,7 @@ class Config(BaseConfig):
         physical_schema_mapping: A mapping from regular expressions to names of schemas in which physical tables for corresponding models will be placed.
         environment_suffix_target: Indicates whether to append the environment name to the schema or table name.
         physical_table_naming_convention: Indicates how tables should be named at the physical layer
+        virtual_environment_mode: Indicates how environments should be handled.
         gateway_managed_virtual_layer: Whether the models' views in the virtual layer are created by the model-specific gateway rather than the default gateway.
         infer_python_dependencies: Whether to statically analyze Python code to automatically infer Python package requirements.
         environment_catalog_mapping: A mapping from regular expressions to catalog names. The catalog name is used to determine the target catalog for a given environment.
@@ -148,12 +153,9 @@ class Config(BaseConfig):
     env_vars: t.Dict[str, str] = {}
     username: str = ""
     physical_schema_mapping: RegexKeyDict = {}
-    environment_suffix_target: EnvironmentSuffixTarget = Field(
-        default=EnvironmentSuffixTarget.default
-    )
-    physical_table_naming_convention: TableNamingConvention = Field(
-        default=TableNamingConvention.default
-    )
+    environment_suffix_target: EnvironmentSuffixTarget = EnvironmentSuffixTarget.default
+    physical_table_naming_convention: TableNamingConvention = TableNamingConvention.default
+    virtual_environment_mode: VirtualEnvironmentMode = VirtualEnvironmentMode.default
     gateway_managed_virtual_layer: bool = False
     infer_python_dependencies: bool = True
     environment_catalog_mapping: RegexKeyDict = {}
@@ -260,6 +262,11 @@ class Config(BaseConfig):
                 "Please specify one or the other"
             )
 
+        if self.plan.use_finalized_state and not self.virtual_environment_mode.is_full:
+            raise ConfigError(
+                "Using the finalized state is only supported when `virtual_environment_mode` is set to `full`."
+            )
+
         if self.environment_catalog_mapping:
             _normalize_identifiers("environment_catalog_mapping")
         if self.physical_schema_mapping:

sqlmesh/core/context.py

@@ -1616,6 +1616,11 @@ class GenericContext(BaseContext, t.Generic[C]):
             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 @@ class GenericContext(BaseContext, t.Generic[C]):
             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,
@@ -2936,7 +2939,7 @@ class GenericContext(BaseContext, t.Generic[C]):
     def _plan_preview_enabled(self) -> bool:
         if self.config.plan.enable_preview is not None:
             return self.config.plan.enable_preview
-        # It is dangerous to enable preview by default for dbt projects that rely on engines that don’t support cloning.
+        # It is dangerous to enable preview by default for dbt projects that rely on engines that don't support cloning.
         # Enabling previews in such cases can result in unintended full refreshes because dbt incremental models rely on
         # the maximum timestamp value in the target table.
         return self._project_type == c.NATIVE or self.engine_adapter.SUPPORTS_CLONING

sqlmesh/core/engine_adapter/base.py

@@ -32,6 +32,7 @@ from sqlmesh.core.engine_adapter.shared import (
     CommentCreationTable,
     CommentCreationView,
     DataObject,
+    DataObjectType,
     EngineRunMode,
     InsertOverwriteStrategy,
     SourceQuery,
@@ -39,13 +40,13 @@ from sqlmesh.core.engine_adapter.shared import (
 )
 from sqlmesh.core.model.kind import TimeColumn
 from sqlmesh.core.schema_diff import SchemaDiffer
-from sqlmesh.utils import columns_to_types_all_known, random_id, CorrelationId
-from sqlmesh.utils.connection_pool import create_connection_pool, ConnectionPool
+from sqlmesh.utils import CorrelationId, columns_to_types_all_known, random_id
+from sqlmesh.utils.connection_pool import ConnectionPool, create_connection_pool
 from sqlmesh.utils.date import TimeLike, make_inclusive, to_time_column
 from sqlmesh.utils.errors import (
+    MissingDefaultCatalogError,
     SQLMeshError,
     UnsupportedCatalogOperationError,
-    MissingDefaultCatalogError,
 )
 from sqlmesh.utils.pandas import columns_to_types_from_df
 
@@ -54,8 +55,8 @@ if t.TYPE_CHECKING:
 
     from sqlmesh.core._typing import SchemaName, SessionProperties, TableName
     from sqlmesh.core.engine_adapter._typing import (
-        BigframeSession,
         DF,
+        BigframeSession,
         PySparkDataFrame,
         PySparkSession,
         Query,
@@ -369,6 +370,12 @@ class EngineAdapter:
             kwargs: Optional create table properties.
         """
         target_table = exp.to_table(table_name)
+
+        target_data_object = self.get_data_object(target_table)
+        table_exists = target_data_object is not None
+        if self.drop_data_object_on_type_mismatch(target_data_object, DataObjectType.TABLE):
+            table_exists = False
+
         source_queries, columns_to_types = self._get_source_queries_and_columns_to_types(
             query_or_df, columns_to_types, target_table=target_table
         )
@@ -390,7 +397,7 @@ class EngineAdapter:
             )
         # All engines support `CREATE TABLE AS` so we use that if the table doesn't already exist and we
         # use `CREATE OR REPLACE TABLE AS` if the engine supports it
-        if self.SUPPORTS_REPLACE_TABLE or not self.table_exists(target_table):
+        if self.SUPPORTS_REPLACE_TABLE or not table_exists:
             return self._create_table_from_source_queries(
                 target_table,
                 source_queries,
@@ -930,6 +937,28 @@ class EngineAdapter:
             )
         )
 
+    def drop_data_object(self, data_object: DataObject, ignore_if_not_exists: bool = True) -> None:
+        """Drops a data object of arbitrary type.
+
+        Args:
+            data_object: The data object to drop.
+            ignore_if_not_exists: If True, no error will be raised if the data object does not exist.
+        """
+        if data_object.type.is_view:
+            self.drop_view(data_object.to_table(), ignore_if_not_exists=ignore_if_not_exists)
+        elif data_object.type.is_materialized_view:
+            self.drop_view(
+                data_object.to_table(), ignore_if_not_exists=ignore_if_not_exists, materialized=True
+            )
+        elif data_object.type.is_table:
+            self.drop_table(data_object.to_table(), exists=ignore_if_not_exists)
+        elif data_object.type.is_managed_table:
+            self.drop_managed_table(data_object.to_table(), exists=ignore_if_not_exists)
+        else:
+            raise SQLMeshError(
+                f"Can't drop data object '{data_object.to_table().sql(dialect=self.dialect)}' of type '{data_object.type.value}'"
+            )
+
     def drop_table(self, table_name: TableName, exists: bool = True) -> None:
         """Drops a table.
 
@@ -1118,6 +1147,12 @@ class EngineAdapter:
         if properties.expressions:
             create_kwargs["properties"] = properties
 
+        if replace:
+            self.drop_data_object_on_type_mismatch(
+                self.get_data_object(view_name),
+                DataObjectType.VIEW if not materialized else DataObjectType.MATERIALIZED_VIEW,
+            )
+
         with source_queries[0] as query:
             self.execute(
                 exp.Create(
@@ -2022,6 +2057,15 @@ class EngineAdapter:
                 )
         self._rename_table(old_table_name, new_table_name)
 
+    def get_data_object(self, target_name: TableName) -> t.Optional[DataObject]:
+        target_table = exp.to_table(target_name)
+        existing_data_objects = self.get_data_objects(
+            schema_(target_table.db, target_table.catalog), {target_table.name}
+        )
+        if existing_data_objects:
+            return existing_data_objects[0]
+        return None
+
     def get_data_objects(
         self, schema_name: SchemaName, object_names: t.Optional[t.Set[str]] = None
     ) -> t.List[DataObject]:
@@ -2483,6 +2527,30 @@ class EngineAdapter:
         table = exp.to_table(table_name)
         self.execute(f"TRUNCATE TABLE {table.sql(dialect=self.dialect, identify=True)}")
 
+    def drop_data_object_on_type_mismatch(
+        self, data_object: t.Optional[DataObject], expected_type: DataObjectType
+    ) -> bool:
+        """Drops a data object if it exists and is not of the expected type.
+
+        Args:
+            data_object: The data object to check.
+            expected_type: The expected type of the data object.
+
+        Returns:
+            True if the data object was dropped, False otherwise.
+        """
+        if data_object is None or data_object.type == expected_type:
+            return False
+
+        logger.warning(
+            "Target data object '%s' is a %s and not a %s, dropping it",
+            data_object.to_table().sql(dialect=self.dialect),
+            data_object.type.value,
+            expected_type.value,
+        )
+        self.drop_data_object(data_object)
+        return True
+
     def _replace_by_key(
         self,
         target_table: TableName,

sqlmesh/core/engine_adapter/redshift.py

@@ -262,7 +262,12 @@ class RedshiftEngineAdapter(
         """
         import pandas as pd
 
-        if not isinstance(query_or_df, pd.DataFrame) or not self.table_exists(table_name):
+        target_data_object = self.get_data_object(table_name)
+        table_exists = target_data_object is not None
+        if self.drop_data_object_on_type_mismatch(target_data_object, DataObjectType.TABLE):
+            table_exists = False
+
+        if not isinstance(query_or_df, pd.DataFrame) or not table_exists:
             return super().replace_query(
                 table_name,
                 query_or_df,

sqlmesh/core/engine_adapter/shared.py

@@ -171,6 +171,9 @@ class DataObject(PydanticModel):
     def is_clustered(self) -> bool:
         return bool(self.clustering_key)
 
+    def to_table(self) -> exp.Table:
+        return exp.table_(self.name, db=self.schema_name, catalog=self.catalog, quoted=True)
+
 
 class CatalogSupport(Enum):
     # The engine has no concept of catalogs

sqlmesh/core/loader.py

@@ -603,6 +603,7 @@ class SqlMeshLoader(Loader):
                 infer_names=self.config.model_naming.infer_names,
                 signal_definitions=signals,
                 default_catalog_per_gateway=self.context.default_catalog_per_gateway,
+                virtual_environment_mode=self.config.virtual_environment_mode,
                 **loading_default_kwargs or {},
             )
 
@@ -683,6 +684,7 @@ class SqlMeshLoader(Loader):
                             audit_definitions=audits,
                             signal_definitions=signals,
                             default_catalog_per_gateway=self.context.default_catalog_per_gateway,
+                            virtual_environment_mode=self.config.virtual_environment_mode,
                         ):
                             if model.enabled:
                                 models[model.fqn] = model

sqlmesh/core/model/decorator.py

@@ -8,6 +8,7 @@ import re
 from sqlglot import exp
 from sqlglot.dialects.dialect import DialectType
 
+from sqlmesh.core.config.common import VirtualEnvironmentMode
 from sqlmesh.core.macros import MacroRegistry
 from sqlmesh.core.signal import SignalRegistry
 from sqlmesh.utils.jinja import JinjaMacroRegistry
@@ -154,6 +155,7 @@ class model(registry_decorator):
         variables: t.Optional[t.Dict[str, t.Any]] = None,
         infer_names: t.Optional[bool] = False,
         blueprint_variables: t.Optional[t.Dict[str, t.Any]] = None,
+        virtual_environment_mode: VirtualEnvironmentMode = VirtualEnvironmentMode.default,
     ) -> Model:
         """Get the model registered by this function."""
         env: t.Dict[str, t.Tuple[t.Any, t.Optional[bool]]] = {}
@@ -228,6 +230,7 @@ class model(registry_decorator):
             "audit_definitions": audit_definitions,
             "signal_definitions": signal_definitions,
             "blueprint_variables": blueprint_variables,
+            "virtual_environment_mode": virtual_environment_mode,
             **rendered_fields,
         }
 

sqlmesh/core/model/definition.py

@@ -1062,6 +1062,7 @@ class _Model(ModelMeta, frozen=True):
             self.gateway,
             self.interval_unit.value if self.interval_unit is not None else None,
             str(self.optimize_query) if self.optimize_query is not None else None,
+            self.virtual_environment_mode.value,
         ]
 
         for column_name, column_type in (self.columns_to_types_ or {}).items():
@@ -2957,6 +2958,7 @@ META_FIELD_CONVERTER: t.Dict[str, t.Callable] = {
         )
     ),
     "formatting": str,
+    "virtual_environment_mode": lambda value: exp.Literal.string(value.value),
 }
 
 

sqlmesh/core/model/meta.py

@@ -10,6 +10,7 @@ from sqlglot.helper import ensure_collection, ensure_list
 from sqlglot.optimizer.normalize_identifiers import normalize_identifiers
 
 from sqlmesh.core import dialect as d
+from sqlmesh.core.config.common import VirtualEnvironmentMode
 from sqlmesh.core.config.linter import LinterConfig
 from sqlmesh.core.dialect import normalize_model_name
 from sqlmesh.core.model.common import (
@@ -83,6 +84,7 @@ class ModelMeta(_Node):
         default=None, exclude=True, alias="ignored_rules"
     )
     formatting: t.Optional[bool] = Field(default=None, exclude=True)
+    virtual_environment_mode: VirtualEnvironmentMode = VirtualEnvironmentMode.default
 
     _bool_validator = bool_validator
     _model_kind_validator = model_kind_validator

sqlmesh/core/plan/builder.py

@@ -16,6 +16,7 @@ from sqlmesh.core.config import (
 )
 from sqlmesh.core.context_diff import ContextDiff
 from sqlmesh.core.environment import EnvironmentNamingInfo
+from sqlmesh.core.plan.common import should_force_rebuild
 from sqlmesh.core.plan.definition import (
     Plan,
     SnapshotMapping,
@@ -162,7 +163,7 @@ class PlanBuilder:
 
         self._start = start
         if not self._start and (
-            self._forward_only_preview_needed or self._auto_restatement_preview_needed
+            self._forward_only_preview_needed or self._non_forward_only_preview_needed
         ):
             self._start = default_start or yesterday_ds()
 
@@ -267,7 +268,6 @@ class PlanBuilder:
         self._ensure_no_new_snapshots_with_restatements()
         self._ensure_new_env_with_changes()
         self._ensure_valid_date_range()
-        self._ensure_no_forward_only_revert()
         self._ensure_no_broken_references()
 
         self._apply_effective_from()
@@ -277,7 +277,7 @@ class PlanBuilder:
 
         self._check_destructive_changes(directly_modified)
         self._categorize_snapshots(dag, indirectly_modified)
-        self._adjust_new_snapshot_intervals()
+        self._adjust_snapshot_intervals()
 
         deployability_index = (
             DeployabilityIndex.create(
@@ -509,21 +509,22 @@ class PlanBuilder:
             ).sorted
         }
 
-    def _adjust_new_snapshot_intervals(self) -> None:
-        old_snapshots = {
-            (old.name, old.version_get_or_generate()): old
-            for _, old in self._context_diff.modified_snapshots.values()
-        }
-
-        for new in self._context_diff.new_snapshots.values():
-            new.intervals = []
-            new.dev_intervals = []
-            old = old_snapshots.get((new.name, new.version_get_or_generate()))
-            if not old:
+    def _adjust_snapshot_intervals(self) -> None:
+        for new, old in self._context_diff.modified_snapshots.values():
+            if not new.is_model or not old.is_model:
                 continue
-            new.merge_intervals(old)
-            if new.is_forward_only:
-                new.dev_intervals = new.intervals.copy()
+            is_same_version = old.version_get_or_generate() == new.version_get_or_generate()
+            if is_same_version and should_force_rebuild(old, new):
+                # If the difference between 2 snapshots requires a full rebuild,
+                # then clear the intervals for the new snapshot.
+                self._context_diff.snapshots[new.snapshot_id].intervals = []
+            elif new.snapshot_id in self._context_diff.new_snapshots:
+                new.intervals = []
+                new.dev_intervals = []
+                if is_same_version:
+                    new.merge_intervals(old)
+                    if new.is_forward_only:
+                        new.dev_intervals = new.intervals.copy()
 
     def _check_destructive_changes(self, directly_modified: t.Set[SnapshotId]) -> None:
         for s_id in sorted(directly_modified):
@@ -587,7 +588,12 @@ class PlanBuilder:
             if not snapshot or not self._is_new_snapshot(snapshot):
                 continue
 
-            forward_only = self._is_forward_only_change(s_id) or self._forward_only
+            forward_only = self._forward_only or self._is_forward_only_change(s_id)
+            if forward_only and s_id.name in self._context_diff.modified_snapshots:
+                new, old = self._context_diff.modified_snapshots[s_id.name]
+                if should_force_rebuild(old, new) or snapshot.is_seed:
+                    # Breaking kind changes and seed changes can't be forward-only.
+                    forward_only = False
 
             if s_id in self._choices:
                 snapshot.categorize_as(self._choices[s_id], forward_only)
@@ -608,15 +614,10 @@ class PlanBuilder:
         s_id = snapshot.snapshot_id
 
         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:
-                # Breaking kind changes and seed changes can't be forward-only.
-                forward_only = False
-
             if self._auto_categorization_enabled:
-                if is_breaking_kind_change:
-                    snapshot.categorize_as(SnapshotChangeCategory.BREAKING, forward_only)
+                new, old = self._context_diff.modified_snapshots[s_id.name]
+                if should_force_rebuild(old, new):
+                    snapshot.categorize_as(SnapshotChangeCategory.BREAKING, False)
                     return
 
                 s_id_with_missing_columns: t.Optional[SnapshotId] = None
@@ -773,7 +774,7 @@ class PlanBuilder:
         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 _is_breaking_kind_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)
@@ -801,27 +802,6 @@ class PlanBuilder:
                     f"Plan end date: '{time_like_to_str(end)}' cannot be in the future (execution time: '{time_like_to_str(self.execution_time)}')"
                 )
 
-    def _ensure_no_forward_only_revert(self) -> None:
-        """Ensures that a previously superseded breaking / non-breaking snapshot is not being
-        used again to replace an existing forward-only snapshot with the same version.
-
-        In other words there is no going back to the original non-forward-only snapshot with
-        the same version once a forward-only change for that version has been introduced.
-        """
-        for name, (candidate, promoted) in self._context_diff.modified_snapshots.items():
-            if (
-                candidate.snapshot_id not in self._context_diff.new_snapshots
-                and candidate.is_model
-                and not candidate.model.forward_only
-                and promoted.is_forward_only
-                and not promoted.is_paused
-                and not candidate.is_no_rebuild
-                and promoted.version == candidate.version
-            ):
-                raise PlanError(
-                    f"Attempted to revert to an unrevertable version of model '{name}'. Run `sqlmesh plan` again to mitigate the issue."
-                )
-
     def _ensure_no_broken_references(self) -> None:
         for snapshot in self._context_diff.snapshots.values():
             broken_references = {
@@ -871,12 +851,18 @@ class PlanBuilder:
         )
 
     @cached_property
-    def _auto_restatement_preview_needed(self) -> bool:
-        return self._is_dev and any(
-            snapshot.model.auto_restatement_cron is not None
-            for snapshot in self._modified_and_added_snapshots
-            if snapshot.is_model
-        )
+    def _non_forward_only_preview_needed(self) -> bool:
+        if not self._is_dev:
+            return False
+        for snapshot in self._modified_and_added_snapshots:
+            if not snapshot.is_model:
+                continue
+            if (
+                not snapshot.virtual_environment_mode.is_full
+                or snapshot.model.auto_restatement_cron is not None
+            ):
+                return True
+        return False
 
     @cached_property
     def _modified_and_added_snapshots(self) -> t.List[Snapshot]:
@@ -886,16 +872,3 @@ class PlanBuilder:
             if snapshot.name in self._context_diff.modified_snapshots
             or snapshot.snapshot_id in self._context_diff.added
         ]
-
-
-def _is_breaking_kind_change(old: Snapshot, new: Snapshot) -> bool:
-    if old.model.kind.name == new.model.kind.name:
-        # If the kind hasn't changed, then it's not a breaking change
-        return False
-    if not old.is_incremental or not new.is_incremental:
-        # If either is not incremental, then it's a breaking change
-        return True
-    if old.model.partitioned_by == new.model.partitioned_by:
-        # If the partitioning hasn't changed, then it's not a breaking change
-        return False
-    return True

sqlmesh/core/plan/common.py

@@ -0,0 +1,19 @@
+from __future__ import annotations
+
+from sqlmesh.core.snapshot import Snapshot
+
+
+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 we need to rebuild
+        return True
+    if old.model.kind.name == new.model.kind.name:
+        # If the kind hasn't changed, then we don't need to rebuild
+        return False
+    if not old.is_incremental or not new.is_incremental:
+        # If either is not incremental, then we need to rebuild
+        return True
+    if old.model.partitioned_by == new.model.partitioned_by:
+        # If the partitioning hasn't changed, then we don't need to rebuild
+        return False
+    return True

sqlmesh/core/plan/stages.py

@@ -1,7 +1,8 @@
 import typing as t
 
 from dataclasses import dataclass
-from sqlmesh.core.environment import EnvironmentStatements, EnvironmentNamingInfo
+from sqlmesh.core.environment import EnvironmentStatements, EnvironmentNamingInfo, Environment
+from sqlmesh.core.plan.common import should_force_rebuild
 from sqlmesh.core.plan.definition import EvaluatablePlan
 from sqlmesh.core.state_sync import StateReader
 from sqlmesh.core.scheduler import merged_missing_intervals, SnapshotToIntervals
@@ -230,8 +231,9 @@ class PlanStagesBuilder:
         all_selected_for_backfill_snapshots = {
             s.snapshot_id for s in snapshots.values() if plan.is_selected_for_backfill(s.name)
         }
+        existing_environment = self.state_reader.get_environment(plan.environment.name)
 
-        self._adjust_intervals(snapshots_by_name, plan)
+        self._adjust_intervals(snapshots_by_name, plan, existing_environment)
 
         deployability_index = DeployabilityIndex.create(snapshots, start=plan.start)
         deployability_index_for_creation = deployability_index
@@ -269,7 +271,7 @@ class PlanStagesBuilder:
                     missing_intervals_after_promote[snapshot] = intervals
 
         promoted_snapshots, demoted_snapshots, demoted_environment_naming_info = (
-            self._get_promoted_demoted_snapshots(plan)
+            self._get_promoted_demoted_snapshots(plan, existing_environment)
         )
 
         stages: t.List[PlanStage] = []
@@ -358,6 +360,7 @@ class PlanStagesBuilder:
             demoted_environment_naming_info,
             snapshots | full_demoted_snapshots,
             deployability_index,
+            plan.is_dev,
         )
         if virtual_layer_update_stage:
             stages.append(virtual_layer_update_stage)
@@ -437,11 +440,18 @@ class PlanStagesBuilder:
         demoted_environment_naming_info: t.Optional[EnvironmentNamingInfo],
         all_snapshots: t.Dict[SnapshotId, Snapshot],
         deployability_index: DeployabilityIndex,
+        is_dev: bool,
     ) -> t.Optional[VirtualLayerUpdateStage]:
-        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}
+        def _should_update_virtual_layer(snapshot: SnapshotTableInfo) -> bool:
+            # Skip virtual layer update for snapshots with virtual environment support disabled
+            virtual_environment_enabled = is_dev or snapshot.virtual_environment_mode.is_full
+            return snapshot.is_model and not snapshot.is_symbolic and virtual_environment_enabled
+
+        promoted_snapshots = {s for s in promoted_snapshots if _should_update_virtual_layer(s)}
+        demoted_snapshots = {s for s in demoted_snapshots if _should_update_virtual_layer(s)}
         if not promoted_snapshots and not demoted_snapshots:
             return None
+
         return VirtualLayerUpdateStage(
             promoted_snapshots=promoted_snapshots,
             demoted_snapshots=demoted_snapshots,
@@ -451,11 +461,10 @@ class PlanStagesBuilder:
         )
 
     def _get_promoted_demoted_snapshots(
-        self, plan: EvaluatablePlan
+        self, plan: EvaluatablePlan, existing_environment: t.Optional[Environment]
     ) -> t.Tuple[
         t.Set[SnapshotTableInfo], t.Set[SnapshotTableInfo], t.Optional[EnvironmentNamingInfo]
     ]:
-        existing_environment = self.state_reader.get_environment(plan.environment.name)
         if existing_environment:
             new_table_infos = {
                 table_info.name: table_info for table_info in plan.environment.promoted_snapshots
@@ -571,10 +580,40 @@ class PlanStagesBuilder:
         return [s for s in snapshots.values() if _should_create(s)]
 
     def _adjust_intervals(
-        self, snapshots_by_name: t.Dict[str, Snapshot], plan: EvaluatablePlan
+        self,
+        snapshots_by_name: t.Dict[str, Snapshot],
+        plan: EvaluatablePlan,
+        existing_environment: t.Optional[Environment],
     ) -> None:
         # Make sure the intervals are up to date and restatements are reflected
         self.state_reader.refresh_snapshot_intervals(snapshots_by_name.values())
+
+        if existing_environment:
+            new_snapshot_ids = set()
+            new_snapshot_versions = set()
+            for s in snapshots_by_name.values():
+                if s.is_model:
+                    new_snapshot_ids.add(s.snapshot_id)
+                    new_snapshot_versions.add(s.name_version)
+            # Only compare to old snapshots that share the same version as the new snapshots
+            old_snapshot_ids = {
+                s.snapshot_id
+                for s in existing_environment.snapshots
+                if s.is_model
+                and s.name_version in new_snapshot_versions
+                and s.snapshot_id not in new_snapshot_ids
+            }
+            if old_snapshot_ids:
+                old_snapshots = self.state_reader.get_snapshots(old_snapshot_ids)
+                for old in old_snapshots.values():
+                    new = snapshots_by_name.get(old.name)
+                    if not new or old.version != new.version:
+                        continue
+                    if should_force_rebuild(old, new):
+                        # If the difference between 2 snapshots requires a full rebuild,
+                        # then clear the intervals for the new snapshot.
+                        new.intervals = []
+
         for new_snapshot in plan.new_snapshots:
             if new_snapshot.is_forward_only:
                 # Forward-only snapshots inherit intervals in dev because of cloning

sqlmesh/core/snapshot/definition.py

@@ -13,7 +13,7 @@ from pydantic import Field
 from sqlglot import exp
 from sqlglot.optimizer.normalize_identifiers import normalize_identifiers
 
-from sqlmesh.core.config import TableNamingConvention
+from sqlmesh.core.config.common import TableNamingConvention, VirtualEnvironmentMode
 from sqlmesh.core import constants as c
 from sqlmesh.core.audit import StandaloneAudit
 from sqlmesh.core.environment import EnvironmentSuffixTarget
@@ -230,6 +230,7 @@ class SnapshotDataVersion(PydanticModel, frozen=True):
     physical_schema_: t.Optional[str] = Field(default=None, alias="physical_schema")
     dev_table_suffix: str
     table_naming_convention: TableNamingConvention = Field(default=TableNamingConvention.default)
+    virtual_environment_mode: VirtualEnvironmentMode = Field(default=VirtualEnvironmentMode.default)
 
     def snapshot_id(self, name: str) -> SnapshotId:
         return SnapshotId(name=name, identifier=self.fingerprint.to_identifier())
@@ -336,7 +337,7 @@ class SnapshotInfoMixin(ModelKindMixin):
     # This can be removed from this model once Pydantic 1 support is dropped (must remain in `Snapshot` though)
     base_table_name_override: t.Optional[str]
     dev_table_suffix: str
-    table_naming_convention: TableNamingConvention = Field(default=TableNamingConvention.default)
+    table_naming_convention: TableNamingConvention
     forward_only: bool
 
     @cached_property
@@ -383,6 +384,10 @@ class SnapshotInfoMixin(ModelKindMixin):
     def fully_qualified_table(self) -> t.Optional[exp.Table]:
         raise NotImplementedError
 
+    @property
+    def virtual_environment_mode(self) -> VirtualEnvironmentMode:
+        raise NotImplementedError
+
     @property
     def is_forward_only(self) -> bool:
         return self.forward_only or self.change_category == SnapshotChangeCategory.FORWARD_ONLY
@@ -443,6 +448,10 @@ class SnapshotInfoMixin(ModelKindMixin):
         if self.is_external:
             return self.name
 
+        if is_deployable and self.virtual_environment_mode.is_dev_only:
+            # Use the model name as is if the target is deployable and the virtual environment mode is set to dev-only
+            return self.name
+
         is_dev_table = not is_deployable
         if is_dev_table:
             version = self.dev_version
@@ -459,6 +468,7 @@ class SnapshotInfoMixin(ModelKindMixin):
             fqt = self.fully_qualified_table.copy()
             fqt.set("catalog", None)
             base_table_name = fqt.sql()
+
         return table_name(
             self.physical_schema,
             base_table_name,
@@ -499,6 +509,10 @@ class SnapshotTableInfo(PydanticModel, SnapshotInfoMixin, frozen=True):
     dev_table_suffix: str
     model_gateway: t.Optional[str] = None
     forward_only: bool = False
+    table_naming_convention: TableNamingConvention = TableNamingConvention.default
+    virtual_environment_mode_: VirtualEnvironmentMode = Field(
+        default=VirtualEnvironmentMode.default, alias="virtual_environment_mode"
+    )
 
     def __lt__(self, other: SnapshotTableInfo) -> bool:
         return self.name < other.name
@@ -530,6 +544,10 @@ class SnapshotTableInfo(PydanticModel, SnapshotInfoMixin, frozen=True):
         """Helper method to return self."""
         return self
 
+    @property
+    def virtual_environment_mode(self) -> VirtualEnvironmentMode:
+        return self.virtual_environment_mode_
+
     @property
     def data_version(self) -> SnapshotDataVersion:
         return SnapshotDataVersion(
@@ -540,6 +558,7 @@ class SnapshotTableInfo(PydanticModel, SnapshotInfoMixin, frozen=True):
             physical_schema=self.physical_schema,
             dev_table_suffix=self.dev_table_suffix,
             table_naming_convention=self.table_naming_convention,
+            virtual_environment_mode=self.virtual_environment_mode,
         )
 
     @property
@@ -623,9 +642,7 @@ class Snapshot(PydanticModel, SnapshotInfoMixin):
     base_table_name_override: t.Optional[str] = None
     next_auto_restatement_ts: t.Optional[int] = None
     dev_table_suffix: str = "dev"
-    table_naming_convention_: TableNamingConvention = Field(
-        default=TableNamingConvention.default, alias="table_naming_convention"
-    )
+    table_naming_convention: TableNamingConvention = TableNamingConvention.default
     forward_only: bool = False
 
     @field_validator("ttl")
@@ -878,10 +895,9 @@ class Snapshot(PydanticModel, SnapshotInfoMixin):
         """
         effective_from_ts = self.normalized_effective_from_ts or 0
         apply_effective_from = effective_from_ts > 0 and self.identifier != other.identifier
-
         for start, end in other.intervals:
             # If the effective_from is set, then intervals that come after it must come from
-            # the current snapshost.
+            # the current snapshots.
             if apply_effective_from and start < effective_from_ts:
                 end = min(end, effective_from_ts)
             if not apply_effective_from or end <= effective_from_ts:
@@ -1035,7 +1051,10 @@ class Snapshot(PydanticModel, SnapshotInfoMixin):
             SnapshotChangeCategory.INDIRECT_NON_BREAKING,
             SnapshotChangeCategory.METADATA,
         )
-        if self.is_model and self.model.physical_version:
+        if self.is_model and not self.virtual_environment_mode.is_full:
+            # Hardcode the version if the virtual environment is not fully enabled.
+            self.version = "novde"
+        elif self.is_model and self.model.physical_version:
             # If the model has a pinned version then use that.
             self.version = self.model.physical_version
         elif is_no_rebuild and self.previous_version:
@@ -1239,6 +1258,7 @@ class Snapshot(PydanticModel, SnapshotInfoMixin):
             model_gateway=self.model_gateway,
             table_naming_convention=self.table_naming_convention,  # type: ignore
             forward_only=self.forward_only,
+            virtual_environment_mode=self.virtual_environment_mode,
         )
 
     @property
@@ -1252,6 +1272,7 @@ class Snapshot(PydanticModel, SnapshotInfoMixin):
             physical_schema=self.physical_schema,
             dev_table_suffix=self.dev_table_suffix,
             table_naming_convention=self.table_naming_convention,
+            virtual_environment_mode=self.virtual_environment_mode,
         )
 
     @property
@@ -1383,6 +1404,7 @@ class Snapshot(PydanticModel, SnapshotInfoMixin):
                 or self.model.forward_only
                 or bool(self.model.physical_version)
                 or self.is_view
+                or not self.virtual_environment_mode.is_full
             )
         )
 
@@ -1396,6 +1418,12 @@ class Snapshot(PydanticModel, SnapshotInfoMixin):
             return t.cast(CustomKind, self.model.kind).materialization
         return None
 
+    @property
+    def virtual_environment_mode(self) -> VirtualEnvironmentMode:
+        return (
+            self.model.virtual_environment_mode if self.is_model else VirtualEnvironmentMode.default
+        )
+
     def _ensure_categorized(self) -> None:
         if not self.change_category:
             raise SQLMeshError(f"Snapshot {self.snapshot_id} has not been categorized yet.")
@@ -1535,14 +1563,20 @@ class DeployabilityIndex(PydanticModel, frozen=True):
         for node in dag:
             if node not in snapshots:
                 continue
-            # Make sure that the node is deployable according to all its parents
-            this_deployable = all(
-                children_deployability_mapping[p_id]
-                for p_id in snapshots[node].parents
-                if p_id in children_deployability_mapping
-            )
+            snapshot = snapshots[node]
+
+            if not snapshot.virtual_environment_mode.is_full:
+                # If the virtual environment is not fully enabled, then the snapshot can never be deployable
+                this_deployable = False
+            else:
+                # Make sure that the node is deployable according to all its parents
+                this_deployable = all(
+                    children_deployability_mapping[p_id]
+                    for p_id in snapshots[node].parents
+                    if p_id in children_deployability_mapping
+                )
+
             if this_deployable:
-                snapshot = snapshots[node]
                 is_forward_only_model = (
                     snapshot.is_model and snapshot.model.forward_only and not snapshot.is_metadata
                 )

sqlmesh/core/snapshot/evaluator.py

@@ -38,7 +38,7 @@ from sqlmesh.core import dialect as d
 from sqlmesh.core.audit import Audit, StandaloneAudit
 from sqlmesh.core.dialect import schema_
 from sqlmesh.core.engine_adapter import EngineAdapter
-from sqlmesh.core.engine_adapter.shared import InsertOverwriteStrategy
+from sqlmesh.core.engine_adapter.shared import InsertOverwriteStrategy, DataObjectType
 from sqlmesh.core.macros import RuntimeStage
 from sqlmesh.core.model import (
     AuditResult,
@@ -934,7 +934,14 @@ class SnapshotEvaluator:
             adapter.transaction(),
             adapter.session(snapshot.model.render_session_properties(**render_kwargs)),
         ):
-            if adapter.table_exists(target_table_name):
+            target_data_object = adapter.get_data_object(target_table_name)
+            table_exists = target_data_object is not None
+            if adapter.drop_data_object_on_type_mismatch(
+                target_data_object, _snapshot_to_data_object_type(snapshot)
+            ):
+                table_exists = False
+
+            if table_exists:
                 evaluation_strategy = _evaluation_strategy(snapshot, adapter)
                 tmp_table_name = snapshot.table_name(is_deployable=False)
                 logger.info(
@@ -2274,8 +2281,10 @@ def _check_destructive_schema_change(
     alter_expressions: t.List[exp.Alter],
     allow_destructive_snapshots: t.Set[str],
 ) -> None:
-    if snapshot.needs_destructive_check(allow_destructive_snapshots) and has_drop_alteration(
-        alter_expressions
+    if (
+        snapshot.is_no_rebuild
+        and snapshot.needs_destructive_check(allow_destructive_snapshots)
+        and has_drop_alteration(alter_expressions)
     ):
         snapshot_name = snapshot.name
         dropped_column_names = get_dropped_column_names(alter_expressions)
@@ -2305,3 +2314,15 @@ def _check_table_db_is_physical_schema(table_name: str, physical_schema: str) ->
         raise SQLMeshError(
             f"Table '{table_name}' is not a part of the physical schema '{physical_schema}' and so can't be dropped."
         )
+
+
+def _snapshot_to_data_object_type(snapshot: Snapshot) -> DataObjectType:
+    if snapshot.is_managed:
+        return DataObjectType.MANAGED_TABLE
+    if snapshot.is_materialized_view:
+        return DataObjectType.MATERIALIZED_VIEW
+    if snapshot.is_view:
+        return DataObjectType.VIEW
+    if snapshot.is_materialized:
+        return DataObjectType.TABLE
+    return DataObjectType.UNKNOWN

sqlmesh/core/state_sync/db/snapshot.py

@@ -173,10 +173,9 @@ class SnapshotState:
                     snapshot.set_unpaused_ts(None)
                     paused_snapshots.append(snapshot.snapshot_id)
 
-                if (
-                    not snapshot.is_forward_only
-                    and target_snapshot.is_forward_only
-                    and not snapshot.unrestorable
+                if not snapshot.unrestorable and (
+                    (target_snapshot.is_forward_only and not snapshot.is_forward_only)
+                    or (snapshot.is_forward_only and not target_snapshot.is_forward_only)
                 ):
                     logger.info("Marking snapshot %s as unrestorable", snapshot.snapshot_id)
                     snapshot.unrestorable = True

sqlmesh/dbt/basemodel.py

@@ -10,6 +10,7 @@ from sqlglot.helper import ensure_list
 
 from sqlmesh.core import dialect as d
 from sqlmesh.core.config.base import UpdateStrategy
+from sqlmesh.core.config.common import VirtualEnvironmentMode
 from sqlmesh.core.model import Model
 from sqlmesh.dbt.column import (
     ColumnConfig,
@@ -345,6 +346,9 @@ class BaseModelConfig(GeneralConfig):
 
     @abstractmethod
     def to_sqlmesh(
-        self, context: DbtContext, audit_definitions: t.Optional[t.Dict[str, ModelAudit]] = None
+        self,
+        context: DbtContext,
+        audit_definitions: t.Optional[t.Dict[str, ModelAudit]] = None,
+        virtual_environment_mode: VirtualEnvironmentMode = VirtualEnvironmentMode.default,
     ) -> Model:
         """Convert DBT model into sqlmesh Model"""

sqlmesh/dbt/loader.py

@@ -117,7 +117,11 @@ class DbtLoader(Loader):
 
         def _to_sqlmesh(config: BMC, context: DbtContext) -> Model:
             logger.debug("Converting '%s' to sqlmesh format", config.canonical_name(context))
-            return config.to_sqlmesh(context, audit_definitions=audits)
+            return config.to_sqlmesh(
+                context,
+                audit_definitions=audits,
+                virtual_environment_mode=self.config.virtual_environment_mode,
+            )
 
         for project in self._load_projects():
             context = project.context.copy()

sqlmesh/dbt/model.py

@@ -8,6 +8,7 @@ from sqlglot.helper import ensure_list
 
 from sqlmesh.core import dialect as d
 from sqlmesh.core.config.base import UpdateStrategy
+from sqlmesh.core.config.common import VirtualEnvironmentMode
 from sqlmesh.core.console import get_console
 from sqlmesh.core.model import (
     EmbeddedKind,
@@ -421,7 +422,10 @@ class ModelConfig(BaseModelConfig):
         }
 
     def to_sqlmesh(
-        self, context: DbtContext, audit_definitions: t.Optional[t.Dict[str, ModelAudit]] = None
+        self,
+        context: DbtContext,
+        audit_definitions: t.Optional[t.Dict[str, ModelAudit]] = None,
+        virtual_environment_mode: VirtualEnvironmentMode = VirtualEnvironmentMode.default,
     ) -> Model:
         """Converts the dbt model into a SQLMesh model."""
         model_dialect = self.dialect(context)
@@ -573,6 +577,7 @@ class ModelConfig(BaseModelConfig):
             # Note: any table dependencies that are not referenced using the `ref` macro will not be included.
             extract_dependencies_from_query=False,
             allow_partials=allow_partials,
+            virtual_environment_mode=virtual_environment_mode,
             **optional_kwargs,
             **model_kwargs,
         )

sqlmesh/dbt/seed.py

@@ -15,6 +15,7 @@ except ImportError:
     SUPPORTS_DELIMITER = False
 from sqlglot import exp
 
+from sqlmesh.core.config.common import VirtualEnvironmentMode
 from sqlmesh.core.model import Model, SeedKind, create_seed_model
 from sqlmesh.dbt.basemodel import BaseModelConfig
 from sqlmesh.dbt.column import ColumnConfig
@@ -38,7 +39,10 @@ class SeedConfig(BaseModelConfig):
     quote_columns: t.Optional[bool] = False
 
     def to_sqlmesh(
-        self, context: DbtContext, audit_definitions: t.Optional[t.Dict[str, ModelAudit]] = None
+        self,
+        context: DbtContext,
+        audit_definitions: t.Optional[t.Dict[str, ModelAudit]] = None,
+        virtual_environment_mode: VirtualEnvironmentMode = VirtualEnvironmentMode.default,
     ) -> Model:
         """Converts the dbt seed into a SQLMesh model."""
         seed_path = self.path.absolute().as_posix()
@@ -83,6 +87,7 @@ class SeedConfig(BaseModelConfig):
             SeedKind(path=seed_path),
             dialect=self.dialect(context),
             audit_definitions=audit_definitions,
+            virtual_environment_mode=virtual_environment_mode,
             **kwargs,
         )
 

sqlmesh/migrations/v0088_add_virtual_environment_mode.py

@@ -0,0 +1,5 @@
+"""Add virtual_environment_mode to the model definition."""
+
+
+def migrate(state_sync, **kwargs):  # type: ignore
+    pass

{sqlmesh-0.209.1.dev13.dist-info → sqlmesh-0.209.1.dev14.dist-info}/METADATA

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

{sqlmesh-0.209.1.dev13.dist-info → sqlmesh-0.209.1.dev14.dist-info}/RECORD

@@ -1,5 +1,5 @@
 sqlmesh/__init__.py,sha256=QjwaamJIdW7voXoS880yAx7tHm-Im4_mqGA-XJgafos,7631
-sqlmesh/_version.py,sha256=Z-QEmLpn7WCZTovKI1S7q9PMPW5I4VTOb_KNgW5Qf5Y,723
+sqlmesh/_version.py,sha256=bHG9Na0Ngc7db0PR46aKmXwZV8939jGLj8kRw2qwQDE,723
 sqlmesh/magics.py,sha256=bEzYqXHcM0P3CjyUZ1O9arlmXAdLAhoglKbQ29fD9AE,41842
 sqlmesh/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sqlmesh/cicd/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -13,12 +13,12 @@ sqlmesh/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sqlmesh/core/_typing.py,sha256=e1f7xO2aZCy38M_3VoDy-XI3shyd99-IFctgIFSgXWM,497
 sqlmesh/core/console.py,sha256=KbIXoxt5hpDENEolY-DpBlPmcWtJ9vzEgF52mjG2jPE,165710
 sqlmesh/core/constants.py,sha256=Wg6qApCRhENA1me7ELUS5GnArKlTBH-8192gQYKQnE8,2759
-sqlmesh/core/context.py,sha256=bFAvnjg3YENIgWVDYfflKA5yW6o6gMEZhiSKBPIrBk8,127613
+sqlmesh/core/context.py,sha256=HFEIAMbxDa7gBvyvR2B6OTJsRuD-JXO2fOKHIAFoDLY,127702
 sqlmesh/core/context_diff.py,sha256=_Ur55fGLJ58Icsp44I4pVhdi7_JHiHq45mWIco9oFzk,21792
 sqlmesh/core/dialect.py,sha256=wJ2cDoxz72LIRJ3iBZdCqtnKMbMUdIftl-AvbVldI28,52413
 sqlmesh/core/environment.py,sha256=odus40R-YzdQdS_IiUq_tFouUXIhnpwmNwo8dE8Aw1k,13041
 sqlmesh/core/lineage.py,sha256=zjB0Zfamo2Fja2r5SSZPMbrEKTXr1WjozZPVqvxdybI,3143
-sqlmesh/core/loader.py,sha256=z8KNT5igXc_g-5X1BPPL9XAbpve3ZQp7OkkX63iT0Gc,41179
+sqlmesh/core/loader.py,sha256=WDceZAqm2ijcZHlEnG1old7p5c9LKvkr4YpbPZ-7hk4,41349
 sqlmesh/core/macros.py,sha256=G1TD1Lv-iTNOh1JtHwRFOrnThqDBFuAQgQJtp6UDe0I,63023
 sqlmesh/core/node.py,sha256=3ChBz1PIMJhp-jzed_GLBrtmEF2v_BVDEM5WNe0ssPk,14658
 sqlmesh/core/notification_target.py,sha256=PPGoDrgbRKxr27vJEu03XqNTQLYTw0ZF_b0yAapxGeI,16158
@@ -40,7 +40,7 @@ sqlmesh/core/audit/definition.py,sha256=iPpGEOwFIXFHQFQGMyapCm7jnlotwMa-gNaCgTwz
 sqlmesh/core/config/__init__.py,sha256=5zxTXjUMuxBj4XlX6bmpIWTp4GsZY5rIdKSCTYbxRBM,2070
 sqlmesh/core/config/base.py,sha256=t8NQmsgQoZSc-k0dlDiCb8t1jj0AMYdGZ-6se9q_Pks,4898
 sqlmesh/core/config/categorizer.py,sha256=6vzUoNLjR6GOEb_2mYVz2TwmMv2BfldgHX2u-Le5HZs,1975
-sqlmesh/core/config/common.py,sha256=HZxek5DrzdFQl22BypSqB_8amsIT8tqUFSgh66Ibxwk,5158
+sqlmesh/core/config/common.py,sha256=Zg0f3-iEfSE4FcJOlSQzbG8gL6CpKpFLCe8dJJgBmJs,5931
 sqlmesh/core/config/connection.py,sha256=NcS1qB0MKIBCfw6vUNLhalVKZTo2igS7VTrcV_T-VgA,88607
 sqlmesh/core/config/feature_flag.py,sha256=JRcD31OG_t2cYc24meKbHDGB0iVID0P07V2oOeB_mgA,203
 sqlmesh/core/config/format.py,sha256=6CXFbvnor56xbldKE-Vrm9k_ABRoY4v6vgIb3mCihiQ,1355
@@ -52,14 +52,14 @@ sqlmesh/core/config/migration.py,sha256=3lZIlmIcQH3_hIEm3Y3jFtvpw0YXzRzAnk4Odikl
 sqlmesh/core/config/model.py,sha256=xDKIHD8WIzsPu7DfpybPM3bLobppttCZjvD3TTVnwps,4182
 sqlmesh/core/config/naming.py,sha256=KVGaxUgswoQajXR_cHFJvgkmEFcU1V182GkOH1SJxuE,326
 sqlmesh/core/config/plan.py,sha256=wJEDfocMcKSMN0-5gVojjIcmJZ0376LJU3tkGMTm-Zc,1558
-sqlmesh/core/config/root.py,sha256=qLb2woEixtmB32dTAAIbKlAVt1yNTMUVhZbRzrbS924,16906
+sqlmesh/core/config/root.py,sha256=xzQxFov0cvmxw90id6YE_OGJEJh38-lbHhA5kWvSh8E,17308
 sqlmesh/core/config/run.py,sha256=rIK0QnN_vArrwps2TXGVEbvao2AnGZgzXo7EliJa42E,852
 sqlmesh/core/config/scheduler.py,sha256=LVEHIln7dqv8ygo4uniji4j9-gfuJlk-WpQU9FAqILs,7031
 sqlmesh/core/config/ui.py,sha256=jsO-S6_d9NkLZGG5pT4mgKgxMF34KzkDociZAMvCX3U,278
 sqlmesh/core/engine_adapter/__init__.py,sha256=two_WTs4UnSNp-fscJh8vOunJq0Xi37EuDuMjKsKuNE,2281
 sqlmesh/core/engine_adapter/_typing.py,sha256=_63pYCThfC39UtPVHY3N0H6qJ1YBT32OqwwR3swolGM,1037
 sqlmesh/core/engine_adapter/athena.py,sha256=AS1w_l_VrFZsc2CIicElg1dtS9y6q5hHHmTg4ECH-xs,26453
-sqlmesh/core/engine_adapter/base.py,sha256=QUHO4z-5IibBD1pKPfYr04yTroDZ4katsV-GHUmFC-Y,104590
+sqlmesh/core/engine_adapter/base.py,sha256=qefboMkuzRn4ctUyuMZiFtL3tSHBZoMzKcpm_90Nvxw,107386
 sqlmesh/core/engine_adapter/base_postgres.py,sha256=DOsOdCJyQAVfA9S0GznuH0J1bonMqYVP_yJLDYcxFYM,6772
 sqlmesh/core/engine_adapter/bigquery.py,sha256=oL3xISn6Mw2jnJareKkeoG3XFCGW4lVof4OorXdQfBA,51468
 sqlmesh/core/engine_adapter/clickhouse.py,sha256=LoPdm_s_s-ZxS1XJPA3Et0iOHeJ1LgqTAFbwBdiqE7A,34912
@@ -69,9 +69,9 @@ sqlmesh/core/engine_adapter/mixins.py,sha256=2f6I97iRoeEX2c_BB5Pu8ruIrozwtCZPrxN
 sqlmesh/core/engine_adapter/mssql.py,sha256=N-l9RReP45hg9CNKCQTrg4BmwKtN-v9xK68JJW-xYc8,17647
 sqlmesh/core/engine_adapter/mysql.py,sha256=lVC-siXZK3iSfqCmBjZNw8uy09Z8la8v8_oUZ-E2OwI,6966
 sqlmesh/core/engine_adapter/postgres.py,sha256=4eXBDKXb6uiu8B7nD60b2p9pbkc8Z1Ycgavw7Necxj4,4626
-sqlmesh/core/engine_adapter/redshift.py,sha256=35T2ZLKozakRNeD0zykWk8RvXomfX9xi4Zg5Y4ZAVhg,16779
+sqlmesh/core/engine_adapter/redshift.py,sha256=RdEPTBmW2zrruiY7mbbbCJnvTCKHcHBep1MgpXoOZl4,17005
 sqlmesh/core/engine_adapter/risingwave.py,sha256=GY0u085TWerl8kTRNJpEutdD5FBsoPijQ0CcOkWOJEE,2359
-sqlmesh/core/engine_adapter/shared.py,sha256=zL2W2t9af9mo80aSO0fz5TqV6mY8_kI5VYLswbKdZyk,13369
+sqlmesh/core/engine_adapter/shared.py,sha256=pvYU-sC2WEIOENm4oG4UrOCWXF56h-FEmlAqAR8TYoA,13500
 sqlmesh/core/engine_adapter/snowflake.py,sha256=IEEzepxNpfqBIMe4ziz2k8fjOcJPeQPZyM3XljymAj0,28874
 sqlmesh/core/engine_adapter/spark.py,sha256=sYkVOPS0X43UPbI0z7Hh_EpKlI36qkOcr4NNFOTQlLs,21045
 sqlmesh/core/engine_adapter/trino.py,sha256=Tws3GxqnC6BmXFohqru1TDxsgPH-21qV6Oky7FaaLpE,15908
@@ -87,23 +87,24 @@ sqlmesh/core/metric/rewriter.py,sha256=GiSTHfn2kinqCfNPYgZPRk93JFLzVaaejHtHDQ0yX
 sqlmesh/core/model/__init__.py,sha256=C8GRZ53xuXEA9hQv3BQS9pNNyd9rZ06R_B96UYGhDu4,1644
 sqlmesh/core/model/cache.py,sha256=csun0RJguHzKX6-qITcOs4fVP4f8_Ts8qiUVV4sHY6Q,7869
 sqlmesh/core/model/common.py,sha256=xCMdwkJXnwjE9-56wNb1HiER0KHmWbBzc2Tm--2u168,25610
-sqlmesh/core/model/decorator.py,sha256=wUUg5t0K559tV9Pqt6FE2EWXt5TPGb4wF2Yg4B4hX4w,9251
-sqlmesh/core/model/definition.py,sha256=uouwIbWA-m2cFXxvDrBVHKxR0ycSAq8Rz3Qv3xY7ewA,113852
+sqlmesh/core/model/decorator.py,sha256=bL-JuNrdBAikZSjVxnXqeB9i0e9qC7jm7yLjwiZ38aU,9470
+sqlmesh/core/model/definition.py,sha256=IxapmZQkSPFpqGA9_mfzA5xGu1AZVxgsR0P1f1-ngus,113980
 sqlmesh/core/model/kind.py,sha256=uN73ycANfM94CxcOdkUTclLansNvwo3wySkkl--QzY0,36322
-sqlmesh/core/model/meta.py,sha256=IE-b_OkCcKzXuQBsopiaf0l5a5Ay903N_64Z1s4cXGk,20064
+sqlmesh/core/model/meta.py,sha256=PCYfLMevlWExRHQtYs1H_158x3I5K-yUXbdjRzH2YQw,20212
 sqlmesh/core/model/schema.py,sha256=_HMYfzK9wWXh7_CQDIIGnuQUD4aiX3o5D2cRp2sERzc,3387
 sqlmesh/core/model/seed.py,sha256=a0M-1zY1gOkN5ph2GQyataEdBSCtq50YjeFk2LyvInI,5058
 sqlmesh/core/plan/__init__.py,sha256=NKSvM7ZBVjw9ho3J65M1wFvG3KURB8PJ0FHHLmtSF44,443
-sqlmesh/core/plan/builder.py,sha256=2Nv3D8SujJfMiDLXZR8uUv95lKZZx95RHVbeJ_H2iLo,41988
+sqlmesh/core/plan/builder.py,sha256=CliBMyjTFTp4pVjV04ocxjLh3i0LjJevWdarZj3af8A,40954
+sqlmesh/core/plan/common.py,sha256=xchdSb_XqQBu0S6OqnpeLBR5XB8Rmr9FRCfO_v4Tl50,768
 sqlmesh/core/plan/definition.py,sha256=yrX_uZMXi29ltkuowWhNUOi1kd0Uq0TQoM574EI6JHo,14019
 sqlmesh/core/plan/evaluator.py,sha256=0oqepq0qZ_tPhAye6Q9gLenBD_8yE3E8AAwt553lz7U,22163
 sqlmesh/core/plan/explainer.py,sha256=aBkvtM9eog_2NIglazSDdG_i9TTCdFSVOkCw5N8O-1k,12028
-sqlmesh/core/plan/stages.py,sha256=n2gBzOdal2oMgwHgL2pns9vLZmkKQb1j6qBZnk5y8NE,21830
+sqlmesh/core/plan/stages.py,sha256=ZxaHdV6G1P8g9fk2kgsFBGJFe8JPPICdoG_8U1FbklY,23743
 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
-sqlmesh/core/snapshot/definition.py,sha256=iYQAIkrAUQmMt7_HTVGcXsdXK4waBVWR8UhqEJ7yLdc,89669
-sqlmesh/core/snapshot/evaluator.py,sha256=brtESRAypTYpltOKyQYQZ8JwpT9OmBOXUR3zR5hJ6qE,91709
+sqlmesh/core/snapshot/definition.py,sha256=dbx9n4vI1Zdddiu6EXB-eM6KjSsepnpVWdjC_2aPcrg,91305
+sqlmesh/core/snapshot/evaluator.py,sha256=h0WoXKWj4ZrehBDJty8AsQ7mq5xvUCCywdpRjH9B1d8,92460
 sqlmesh/core/state_sync/__init__.py,sha256=B60xj-_Xk-4jas3UphLvwkuf04G-9AyGckcblXE0aRg,869
 sqlmesh/core/state_sync/base.py,sha256=AdqWmbhnvRFqVcFK6L01uCvpBVAYGuMrm4P0D3u_NaU,18334
 sqlmesh/core/state_sync/cache.py,sha256=0AsYdQyBqbLdJvkBQ-hDAipsvnn_jSps-nya-Q4XeL0,5337
@@ -114,7 +115,7 @@ sqlmesh/core/state_sync/db/environment.py,sha256=iTxrdNlKB36S54PUdlqEqlxiAZJtKNE
 sqlmesh/core/state_sync/db/facade.py,sha256=WWditN46A9DXHDcHT7kUZaCfkkjcaDfMC9qO1EfH4Og,25266
 sqlmesh/core/state_sync/db/interval.py,sha256=aMQSF42bVOUU05g7oizcrKR6TBVzR6TJppxzlxkmJFU,17985
 sqlmesh/core/state_sync/db/migrator.py,sha256=2LNUwOBNFkA1ntp-Z93S_OWxFQhOBj3ZD_ZqPCyPEAE,18139
-sqlmesh/core/state_sync/db/snapshot.py,sha256=SpVg55CB4FB4DX1ZXVSJrjdek_W0RNYEkgrQBkCPJIg,29534
+sqlmesh/core/state_sync/db/snapshot.py,sha256=x7JxtOttjE9NccWfjIWURixR2y8AT6OjgEL6FiQV1Jc,29586
 sqlmesh/core/state_sync/db/utils.py,sha256=204OpT3ISFPCwWP9Aqq8nr6ETl24sbG5uOyo86IJv6E,3819
 sqlmesh/core/state_sync/db/version.py,sha256=fl5g1tNMYu8O6WTN4J3bciwjGq0c5nZlRDlxxRKGU78,2210
 sqlmesh/core/test/__init__.py,sha256=e83TJPwPRR_rAG29Y0OVbZb-5oWVBzz-_wrcd22Qk10,418
@@ -125,19 +126,19 @@ sqlmesh/core/test/result.py,sha256=6gOKEsERciHhcrw9TedtNr7g1ynTO7UwA5-PPrzvYuM,4
 sqlmesh/core/test/runner.py,sha256=8I-cL7Q9CggLvET_GPkrXB2YjlyCIHrvbFbbRDnSHRE,6169
 sqlmesh/dbt/__init__.py,sha256=KUv-lW5sG9D2ceXAIzA4MLcjyhzq3E-7qJP4P_PH2EU,144
 sqlmesh/dbt/adapter.py,sha256=pV8b8m_wqK3YJo_6D5b6cZBwgewFAPvAlvLO51UCBl4,16948
-sqlmesh/dbt/basemodel.py,sha256=XuiK9-r5JWzvZGEk98Jt4ukR2exfMDsotGZqYx5xluc,12561
+sqlmesh/dbt/basemodel.py,sha256=YmrgE53nrRdo4kCFkuivOPRnqhmAnQ1_XVqxYjGmNRI,12731
 sqlmesh/dbt/builtin.py,sha256=p4E1rmSLM0B5PHcFWA9J7FwScR90pIPqiMN8G4M3sBM,15173
 sqlmesh/dbt/column.py,sha256=Kvj_N3D_QegcoNQG7VqRiqy-FRfupud-6ilhlykBOgE,1873
 sqlmesh/dbt/common.py,sha256=g4PAL-sEdlnfb_zT-WW3xh-oamyCUoK8dUiDEMVwDWI,7804
 sqlmesh/dbt/context.py,sha256=dxClM-G1IeMbP0v5yxC_va8QNU-uKghW2dBlSZHJOk0,10331
-sqlmesh/dbt/loader.py,sha256=EqPcPT-RgLo52iMiDc9eUb8tWrsvdR8RoRJG06FStBw,15576
+sqlmesh/dbt/loader.py,sha256=Loc-yNHop-Gop80tDhziTPJwOQ01jlW6CcAV1vFsS_Q,15702
 sqlmesh/dbt/manifest.py,sha256=jlafUYdoG7gS2pzvJrt9JfC2afbAMORhBbBUaLl-ZTM,24894
-sqlmesh/dbt/model.py,sha256=FgQpl8pUNOnihGUo5PYdqOqqOX3XtfDHX3xEJc-CVC4,25782
+sqlmesh/dbt/model.py,sha256=eAkTnj0nh7huBFXGAO8ckr5chvdAFrqbw-gOs6uZ_NE,26015
 sqlmesh/dbt/package.py,sha256=IBBQueVB4_4C9tIk0-GUL-O2uibNxXu6W2a4AeHHcOU,4322
 sqlmesh/dbt/profile.py,sha256=Fz2c0dJNN0xBgYEogCIKBTByjNvlA2BVBzOLQCfdEfM,3788
 sqlmesh/dbt/project.py,sha256=a21czHhdcm2J80Zllj2q6VvH-W_rDtlXHa8wmvHaLTo,4036
 sqlmesh/dbt/relation.py,sha256=rgDJQUuENjqq7kpMJJ6AdlgwYmcYjA1oFj6LCYCS-Hg,227
-sqlmesh/dbt/seed.py,sha256=E7pFhtGwRrC9U_VZJNABwLTa-Nk4OeD-gOtjSpvYmDA,4251
+sqlmesh/dbt/seed.py,sha256=UuPUTXpj3nL3JxX1fAReS263zPo31Hmj8dfOctF1oh8,4484
 sqlmesh/dbt/source.py,sha256=IZK-aOV-KdWIOPuXqRjJZAZ7phW1HUXoHtE-3clgkx4,4125
 sqlmesh/dbt/target.py,sha256=aHPt0jSb-Rsqg-uGYZY_rwIXUCmJ8YmsaGh2HiczWbI,42831
 sqlmesh/dbt/test.py,sha256=aOTKqYpVafff-TU4Xhbc9eZr6QAuFLMxIu_sV-18JLQ,8282
@@ -264,6 +265,7 @@ sqlmesh/migrations/v0084_normalize_quote_when_matched_and_merge_filter.py,sha256
 sqlmesh/migrations/v0085_deterministic_repr.py,sha256=mkbZV0rzXJ5bmN1Y75kFI9T6gbnx_sy-zn_UzbOL1Sg,4265
 sqlmesh/migrations/v0086_check_deterministic_bug.py,sha256=WiYcmhQD434GXWiiakQtcy9ESmB35spXMltV43nvU7Q,2953
 sqlmesh/migrations/v0087_normalize_blueprint_variables.py,sha256=GI6KKA-6PtONUoOnyvLpRTUmPjbpa-CKhDa0iqJW01U,4421
+sqlmesh/migrations/v0088_add_virtual_environment_mode.py,sha256=rm6k7CRy2uHozo1Oy17D8WhiV1JldPNCpJ8PukoHSwM,122
 sqlmesh/migrations/v0088_warn_about_variable_python_env_diffs.py,sha256=zCLT6Yqwny73SlfACWjO1bZfs8lZ7gJBov5Iz4akwiQ,3254
 sqlmesh/schedulers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sqlmesh/utils/__init__.py,sha256=51VqA2etTZ6kX54250s1hN5ui7D89OeUTUQ9kgMze7s,11554
@@ -289,7 +291,7 @@ sqlmesh/utils/pydantic.py,sha256=o_NsXbIpDqNpUA1Uc5xF0ZzoXQYYB0DfHwdRxBwXPNk,120
 sqlmesh/utils/rich.py,sha256=cwQ5nJ6sgz64xHtoh6_ec7ReV5YpsOGhMtUJnwoRfEI,3549
 sqlmesh/utils/windows.py,sha256=r7Yin4WEwbvH7sKA3hOJtRsclmscNuBeCklCfVPvtQs,611
 sqlmesh/utils/yaml.py,sha256=hvo5lmybYLcIx4p6CQwufS8X4MbwS60lEBnCmYJCXmU,2336
-sqlmesh-0.209.1.dev13.dist-info/licenses/LICENSE,sha256=OlMefUjgWJdULtf84BLW0AZZcY8DwdgQqb_1j2862j8,11346
+sqlmesh-0.209.1.dev14.dist-info/licenses/LICENSE,sha256=OlMefUjgWJdULtf84BLW0AZZcY8DwdgQqb_1j2862j8,11346
 sqlmesh_dbt/__init__.py,sha256=awYS5y5mz-1NUmx6i5h5NSTJ7tidRl9NC0FAnFWSF6U,350
 sqlmesh_dbt/cli.py,sha256=Ekn77WLMmyyr31aoDoWrZp5DS0rfiddy7pNohBK8G0s,2115
 sqlmesh_dbt/console.py,sha256=1B0B5_R1DlrEkyWVDl8G78-B6_K-ZtLPsQEhqPCfLEU,188
@@ -411,8 +413,8 @@ web/server/api/endpoints/models.py,sha256=kwj0s7uve3iZSMfmjkoPVMFMeY1sD0peTeyrWf
 web/server/api/endpoints/modules.py,sha256=8hqqgonGay_mJmpCw0IdbjsPhWlQH2VLdKAqha-myac,468
 web/server/api/endpoints/plan.py,sha256=bbbY50W_2MsZSTxOHWMKz0tbIm75nsRSlPy8GI2fg9Q,9306
 web/server/api/endpoints/table_diff.py,sha256=SCy3-pr5x6bEEiOaZGCDbiHQhpgxwmnz3Acqa2Ie6jI,2090
-sqlmesh-0.209.1.dev13.dist-info/METADATA,sha256=xyA8vDp0_wasj_KFmp6AZoegsW7YBPLiaOnzE_ndzf4,26686
-sqlmesh-0.209.1.dev13.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-sqlmesh-0.209.1.dev13.dist-info/entry_points.txt,sha256=sHAf6tQczIM8xZoduN4qaUjV7QEPVUUW_LCT8EDUMv4,155
-sqlmesh-0.209.1.dev13.dist-info/top_level.txt,sha256=RQ-33FPe2IgL0rgossAfJkCRtqslz9b7wFARqiWLC5Q,24
-sqlmesh-0.209.1.dev13.dist-info/RECORD,,
+sqlmesh-0.209.1.dev14.dist-info/METADATA,sha256=dL1K4Bz229XuuJr3I_ZJNxFcMBlII5PcA4wJIxAGHHw,26686
+sqlmesh-0.209.1.dev14.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+sqlmesh-0.209.1.dev14.dist-info/entry_points.txt,sha256=sHAf6tQczIM8xZoduN4qaUjV7QEPVUUW_LCT8EDUMv4,155
+sqlmesh-0.209.1.dev14.dist-info/top_level.txt,sha256=RQ-33FPe2IgL0rgossAfJkCRtqslz9b7wFARqiWLC5Q,24
+sqlmesh-0.209.1.dev14.dist-info/RECORD,,