sqlmesh 0.225.1.dev26__py3-none-any.whl → 0.228.2__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.225.1.dev26'
-__version_tuple__ = version_tuple = (0, 225, 1, 'dev26')
+__version__ = version = '0.228.2'
+__version_tuple__ = version_tuple = (0, 228, 2)
 
 __commit_id__ = commit_id = None

sqlmesh/core/config/connection.py

@@ -17,6 +17,7 @@ from pydantic_core import from_json
 from packaging import version
 from sqlglot import exp
 from sqlglot.helper import subclasses
+from sqlglot.errors import ParseError
 
 from sqlmesh.core import engine_adapter
 from sqlmesh.core.config.base import BaseConfig
@@ -238,6 +239,7 @@ class DuckDBAttachOptions(BaseConfig):
     data_path: t.Optional[str] = None
     encrypted: bool = False
     data_inlining_row_limit: t.Optional[int] = None
+    metadata_schema: t.Optional[str] = None
 
     def to_sql(self, alias: str) -> str:
         options = []
@@ -259,6 +261,8 @@ class DuckDBAttachOptions(BaseConfig):
                 options.append("ENCRYPTED")
             if self.data_inlining_row_limit is not None:
                 options.append(f"DATA_INLINING_ROW_LIMIT {self.data_inlining_row_limit}")
+            if self.metadata_schema is not None:
+                options.append(f"METADATA_SCHEMA '{self.metadata_schema}'")
 
         options_sql = f" ({', '.join(options)})" if options else ""
         alias_sql = ""
@@ -1887,6 +1891,7 @@ class TrinoConnectionConfig(ConnectionConfig):
 
     # SQLMesh options
     schema_location_mapping: t.Optional[dict[re.Pattern, str]] = None
+    timestamp_mapping: t.Optional[dict[exp.DataType, exp.DataType]] = None
     concurrent_tasks: int = 4
     register_comments: bool = True
     pre_ping: t.Literal[False] = False
@@ -1911,6 +1916,34 @@ class TrinoConnectionConfig(ConnectionConfig):
                 )
         return compiled
 
+    @field_validator("timestamp_mapping", mode="before")
+    @classmethod
+    def _validate_timestamp_mapping(
+        cls, value: t.Optional[dict[str, str]]
+    ) -> t.Optional[dict[exp.DataType, exp.DataType]]:
+        if value is None:
+            return value
+
+        result: dict[exp.DataType, exp.DataType] = {}
+        for source_type, target_type in value.items():
+            try:
+                source_datatype = exp.DataType.build(source_type)
+            except ParseError:
+                raise ConfigError(
+                    f"Invalid SQL type string in timestamp_mapping: "
+                    f"'{source_type}' is not a valid SQL data type."
+                )
+            try:
+                target_datatype = exp.DataType.build(target_type)
+            except ParseError:
+                raise ConfigError(
+                    f"Invalid SQL type string in timestamp_mapping: "
+                    f"'{target_type}' is not a valid SQL data type."
+                )
+            result[source_datatype] = target_datatype
+
+        return result
+
     @model_validator(mode="after")
     def _root_validator(self) -> Self:
         port = self.port
@@ -2013,7 +2046,10 @@ class TrinoConnectionConfig(ConnectionConfig):
 
     @property
     def _extra_engine_config(self) -> t.Dict[str, t.Any]:
-        return {"schema_location_mapping": self.schema_location_mapping}
+        return {
+            "schema_location_mapping": self.schema_location_mapping,
+            "timestamp_mapping": self.timestamp_mapping,
+        }
 
 
 class ClickhouseConnectionConfig(ConnectionConfig):

sqlmesh/core/context.py

@@ -115,6 +115,7 @@ from sqlmesh.core.test import (
     ModelTestMetadata,
     generate_test,
     run_tests,
+    filter_tests_by_patterns,
 )
 from sqlmesh.core.user import User
 from sqlmesh.utils import UniqueKeyDict, Verbosity
@@ -154,6 +155,8 @@ if t.TYPE_CHECKING:
     )
     from sqlmesh.core.snapshot import Node
 
+    from sqlmesh.core.snapshot.definition import Intervals
+
     ModelOrSnapshot = t.Union[str, Model, Snapshot]
     NodeOrSnapshot = t.Union[str, Model, StandaloneAudit, Snapshot]
 
@@ -276,6 +279,7 @@ class ExecutionContext(BaseContext):
         default_dialect: t.Optional[str] = None,
         default_catalog: t.Optional[str] = None,
         is_restatement: t.Optional[bool] = None,
+        parent_intervals: t.Optional[Intervals] = None,
         variables: t.Optional[t.Dict[str, t.Any]] = None,
         blueprint_variables: t.Optional[t.Dict[str, t.Any]] = None,
     ):
@@ -287,6 +291,7 @@ class ExecutionContext(BaseContext):
         self._variables = variables or {}
         self._blueprint_variables = blueprint_variables or {}
         self._is_restatement = is_restatement
+        self._parent_intervals = parent_intervals
 
     @property
     def default_dialect(self) -> t.Optional[str]:
@@ -315,6 +320,10 @@ class ExecutionContext(BaseContext):
     def is_restatement(self) -> t.Optional[bool]:
         return self._is_restatement
 
+    @property
+    def parent_intervals(self) -> t.Optional[Intervals]:
+        return self._parent_intervals
+
     def var(self, var_name: str, default: t.Optional[t.Any] = None) -> t.Optional[t.Any]:
         """Returns a variable value."""
         return self._variables.get(var_name.lower(), default)
@@ -390,6 +399,11 @@ class GenericContext(BaseContext, t.Generic[C]):
         self._standalone_audits: UniqueKeyDict[str, StandaloneAudit] = UniqueKeyDict(
             "standaloneaudits"
         )
+        self._model_test_metadata: t.List[ModelTestMetadata] = []
+        self._model_test_metadata_path_index: t.Dict[Path, t.List[ModelTestMetadata]] = {}
+        self._model_test_metadata_fully_qualified_name_index: t.Dict[str, ModelTestMetadata] = {}
+        self._models_with_tests: t.Set[str] = set()
+
         self._macros: UniqueKeyDict[str, ExecutableOrMacro] = UniqueKeyDict("macros")
         self._metrics: UniqueKeyDict[str, Metric] = UniqueKeyDict("metrics")
         self._jinja_macros = JinjaMacroRegistry()
@@ -628,6 +642,10 @@ class GenericContext(BaseContext, t.Generic[C]):
         self._excluded_requirements.clear()
         self._linters.clear()
         self._environment_statements = []
+        self._model_test_metadata.clear()
+        self._model_test_metadata_path_index.clear()
+        self._model_test_metadata_fully_qualified_name_index.clear()
+        self._models_with_tests.clear()
 
         for loader, project in zip(self._loaders, loaded_projects):
             self._jinja_macros = self._jinja_macros.merge(project.jinja_macros)
@@ -640,6 +658,16 @@ class GenericContext(BaseContext, t.Generic[C]):
             self._excluded_requirements.update(project.excluded_requirements)
             self._environment_statements.extend(project.environment_statements)
 
+            self._model_test_metadata.extend(project.model_test_metadata)
+            for metadata in project.model_test_metadata:
+                if metadata.path not in self._model_test_metadata_path_index:
+                    self._model_test_metadata_path_index[metadata.path] = []
+                self._model_test_metadata_path_index[metadata.path].append(metadata)
+                self._model_test_metadata_fully_qualified_name_index[
+                    metadata.fully_qualified_test_name
+                ] = metadata
+                self._models_with_tests.add(metadata.model_name)
+
             config = loader.config
             self._linters[config.project] = Linter.from_rules(
                 BUILTIN_RULES.union(project.user_rules), config.linter
@@ -1041,6 +1069,11 @@ class GenericContext(BaseContext, t.Generic[C]):
         """Returns all registered standalone audits in this context."""
         return MappingProxyType(self._standalone_audits)
 
+    @property
+    def models_with_tests(self) -> t.Set[str]:
+        """Returns all models with tests in this context."""
+        return self._models_with_tests
+
     @property
     def snapshots(self) -> t.Dict[str, Snapshot]:
         """Generates and returns snapshots based on models registered in this context.
@@ -2212,7 +2245,7 @@ class GenericContext(BaseContext, t.Generic[C]):
 
             pd.set_option("display.max_columns", None)
 
-        test_meta = self.load_model_tests(tests=tests, patterns=match_patterns)
+        test_meta = self.select_tests(tests=tests, patterns=match_patterns)
 
         result = run_tests(
             model_test_metadata=test_meta,
@@ -2271,6 +2304,7 @@ class GenericContext(BaseContext, t.Generic[C]):
                 snapshot=snapshot,
                 start=start,
                 end=end,
+                execution_time=execution_time,
                 snapshots=self.snapshots,
             ):
                 audit_id = f"{audit_result.audit.name}"
@@ -3184,18 +3218,34 @@ class GenericContext(BaseContext, t.Generic[C]):
 
         return all_violations
 
-    def load_model_tests(
-        self, tests: t.Optional[t.List[str]] = None, patterns: list[str] | None = None
+    def select_tests(
+        self,
+        tests: t.Optional[t.List[str]] = None,
+        patterns: t.Optional[t.List[str]] = None,
     ) -> t.List[ModelTestMetadata]:
-        # If a set of specific test path(s) are provided, we can use a single loader
-        # since it's not required to walk every tests/ folder in each repo
-        loaders = [self._loaders[0]] if tests else self._loaders
+        """Filter pre-loaded test metadata based on tests and patterns."""
+
+        test_meta = self._model_test_metadata
+
+        if tests:
+            filtered_tests = []
+            for test in tests:
+                if "::" in test:
+                    if test in self._model_test_metadata_fully_qualified_name_index:
+                        filtered_tests.append(
+                            self._model_test_metadata_fully_qualified_name_index[test]
+                        )
+                else:
+                    test_path = Path(test)
+                    if test_path in self._model_test_metadata_path_index:
+                        filtered_tests.extend(self._model_test_metadata_path_index[test_path])
+
+            test_meta = filtered_tests
 
-        model_tests = []
-        for loader in loaders:
-            model_tests.extend(loader.load_model_tests(tests=tests, patterns=patterns))
+        if patterns:
+            test_meta = filter_tests_by_patterns(test_meta, patterns)
 
-        return model_tests
+        return test_meta
 
 
 class Context(GenericContext[Config]):

sqlmesh/core/dialect.py

@@ -803,8 +803,15 @@ def text_diff(
     return "\n".join(unified_diff(a_sql, b_sql))
 
 
+WS_OR_COMMENT = r"(?:\s|--[^\n]*\n|/\*.*?\*/)"
+HEADER = r"\b(?:model|audit)\b(?=\s*\()"
+KEY_BOUNDARY = r"(?:\(|,)"  # key is preceded by either '(' or ','
+DIALECT_VALUE = r"['\"]?(?P<dialect>[a-z][a-z0-9]*)['\"]?"
+VALUE_BOUNDARY = r"(?=,|\))"  # value is followed by comma or closing paren
+
 DIALECT_PATTERN = re.compile(
-    r"(model|audit).*?\(.*?dialect\s+'?([a-z]*)", re.IGNORECASE | re.DOTALL
+    rf"{HEADER}.*?{KEY_BOUNDARY}{WS_OR_COMMENT}*dialect{WS_OR_COMMENT}+{DIALECT_VALUE}{WS_OR_COMMENT}*{VALUE_BOUNDARY}",
+    re.IGNORECASE | re.DOTALL,
 )
 
 
@@ -895,7 +902,8 @@ def parse(
         A list of the parsed expressions: [Model, *Statements, Query, *Statements]
     """
     match = match_dialect and DIALECT_PATTERN.search(sql[:MAX_MODEL_DEFINITION_SIZE])
-    dialect = Dialect.get_or_raise(match.group(2) if match else default_dialect)
+    dialect_str = match.group("dialect") if match else None
+    dialect = Dialect.get_or_raise(dialect_str or default_dialect)
 
     tokens = dialect.tokenize(sql)
     chunks: t.List[t.Tuple[t.List[Token], ChunkType]] = [([], ChunkType.SQL)]

sqlmesh/core/engine_adapter/base.py

@@ -811,6 +811,7 @@ class EngineAdapter:
         column_descriptions: t.Optional[t.Dict[str, str]] = None,
         expressions: t.Optional[t.List[exp.PrimaryKey]] = None,
         is_view: bool = False,
+        materialized: bool = False,
     ) -> exp.Schema:
         """
         Build a schema expression for a table, columns, column comments, and additional schema properties.
@@ -823,6 +824,7 @@ class EngineAdapter:
                 target_columns_to_types=target_columns_to_types,
                 column_descriptions=column_descriptions,
                 is_view=is_view,
+                materialized=materialized,
             )
             + expressions,
         )
@@ -832,6 +834,7 @@ class EngineAdapter:
         target_columns_to_types: t.Dict[str, exp.DataType],
         column_descriptions: t.Optional[t.Dict[str, str]] = None,
         is_view: bool = False,
+        materialized: bool = False,
     ) -> t.List[exp.ColumnDef]:
         engine_supports_schema_comments = (
             self.COMMENT_CREATION_VIEW.supports_schema_def
@@ -1260,7 +1263,11 @@ class EngineAdapter:
         schema: t.Union[exp.Table, exp.Schema] = exp.to_table(view_name)
         if target_columns_to_types:
             schema = self._build_schema_exp(
-                exp.to_table(view_name), target_columns_to_types, column_descriptions, is_view=True
+                exp.to_table(view_name),
+                target_columns_to_types,
+                column_descriptions,
+                is_view=True,
+                materialized=materialized,
             )
 
         properties = create_kwargs.pop("properties", None)

sqlmesh/core/engine_adapter/databricks.py

@@ -78,21 +78,21 @@ class DatabricksEngineAdapter(SparkEngineAdapter, GrantsFromInfoSchemaMixin):
     def _use_spark_session(self) -> bool:
         if self.can_access_spark_session(bool(self._extra_config.get("disable_spark_session"))):
             return True
-        return (
-            self.can_access_databricks_connect(
-                bool(self._extra_config.get("disable_databricks_connect"))
-            )
-            and (
-                {
-                    "databricks_connect_server_hostname",
-                    "databricks_connect_access_token",
-                }.issubset(self._extra_config)
-            )
-            and (
-                "databricks_connect_cluster_id" in self._extra_config
-                or "databricks_connect_use_serverless" in self._extra_config
-            )
-        )
+
+        if self.can_access_databricks_connect(
+            bool(self._extra_config.get("disable_databricks_connect"))
+        ):
+            if self._extra_config.get("databricks_connect_use_serverless"):
+                return True
+
+            if {
+                "databricks_connect_cluster_id",
+                "databricks_connect_server_hostname",
+                "databricks_connect_access_token",
+            }.issubset(self._extra_config):
+                return True
+
+        return False
 
     @property
     def is_spark_session_connection(self) -> bool:
@@ -108,7 +108,7 @@ class DatabricksEngineAdapter(SparkEngineAdapter, GrantsFromInfoSchemaMixin):
 
         connect_kwargs = dict(
             host=self._extra_config["databricks_connect_server_hostname"],
-            token=self._extra_config["databricks_connect_access_token"],
+            token=self._extra_config.get("databricks_connect_access_token"),
         )
         if "databricks_connect_use_serverless" in self._extra_config:
             connect_kwargs["serverless"] = True
@@ -394,3 +394,20 @@ class DatabricksEngineAdapter(SparkEngineAdapter, GrantsFromInfoSchemaMixin):
             expressions.append(clustered_by_exp)
             properties = exp.Properties(expressions=expressions)
         return properties
+
+    def _build_column_defs(
+        self,
+        target_columns_to_types: t.Dict[str, exp.DataType],
+        column_descriptions: t.Optional[t.Dict[str, str]] = None,
+        is_view: bool = False,
+        materialized: bool = False,
+    ) -> t.List[exp.ColumnDef]:
+        # Databricks requires column types to be specified when adding column comments
+        # in CREATE MATERIALIZED VIEW statements. Override is_view to False to force
+        # column types to be included when comments are present.
+        if is_view and materialized and column_descriptions:
+            is_view = False
+
+        return super()._build_column_defs(
+            target_columns_to_types, column_descriptions, is_view, materialized
+        )

sqlmesh/core/engine_adapter/fabric.py

@@ -7,19 +7,20 @@ import time
 from functools import cached_property
 from sqlglot import exp
 from tenacity import retry, stop_after_attempt, wait_exponential, retry_if_result
-from sqlmesh.core.engine_adapter.mixins import LogicalMergeMixin
 from sqlmesh.core.engine_adapter.mssql import MSSQLEngineAdapter
 from sqlmesh.core.engine_adapter.shared import (
     InsertOverwriteStrategy,
 )
 from sqlmesh.utils.errors import SQLMeshError
 from sqlmesh.utils.connection_pool import ConnectionPool
+from sqlmesh.core.schema_diff import TableAlterOperation
+from sqlmesh.utils import random_id
 
 
 logger = logging.getLogger(__name__)
 
 
-class FabricEngineAdapter(LogicalMergeMixin, MSSQLEngineAdapter):
+class FabricEngineAdapter(MSSQLEngineAdapter):
     """
     Adapter for Microsoft Fabric.
     """
@@ -154,6 +155,113 @@ class FabricEngineAdapter(LogicalMergeMixin, MSSQLEngineAdapter):
                 f"Unable to switch catalog to {catalog_name}, catalog ended up as {catalog_after_switch}"
             )
 
+    def alter_table(
+        self, alter_expressions: t.Union[t.List[exp.Alter], t.List[TableAlterOperation]]
+    ) -> None:
+        """
+        Applies alter expressions to a table. Fabric has limited support for ALTER TABLE,
+        so this method implements a workaround for column type changes.
+        This method is self-contained and sets its own catalog context.
+        """
+        if not alter_expressions:
+            return
+
+        # Get the target table from the first expression to determine the correct catalog.
+        first_op = alter_expressions[0]
+        expression = first_op.expression if isinstance(first_op, TableAlterOperation) else first_op
+        if not isinstance(expression, exp.Alter) or not expression.this.catalog:
+            # Fallback for unexpected scenarios
+            logger.warning(
+                "Could not determine catalog from alter expression, executing with current context."
+            )
+            super().alter_table(alter_expressions)
+            return
+
+        target_catalog = expression.this.catalog
+        self.set_current_catalog(target_catalog)
+
+        with self.transaction():
+            for op in alter_expressions:
+                expression = op.expression if isinstance(op, TableAlterOperation) else op
+
+                if not isinstance(expression, exp.Alter):
+                    self.execute(expression)
+                    continue
+
+                for action in expression.actions:
+                    table_name = expression.this
+
+                    table_name_without_catalog = table_name.copy()
+                    table_name_without_catalog.set("catalog", None)
+
+                    is_type_change = isinstance(action, exp.AlterColumn) and action.args.get(
+                        "dtype"
+                    )
+
+                    if is_type_change:
+                        column_to_alter = action.this
+                        new_type = action.args["dtype"]
+                        temp_column_name_str = f"{column_to_alter.name}__{random_id(short=True)}"
+                        temp_column_name = exp.to_identifier(temp_column_name_str)
+
+                        logger.info(
+                            "Applying workaround for column '%s' on table '%s' to change type to '%s'.",
+                            column_to_alter.sql(),
+                            table_name.sql(),
+                            new_type.sql(),
+                        )
+
+                        # Step 1: Add a temporary column.
+                        add_column_expr = exp.Alter(
+                            this=table_name_without_catalog.copy(),
+                            kind="TABLE",
+                            actions=[
+                                exp.ColumnDef(this=temp_column_name.copy(), kind=new_type.copy())
+                            ],
+                        )
+                        add_sql = self._to_sql(add_column_expr)
+                        self.execute(add_sql)
+
+                        # Step 2: Copy and cast data.
+                        update_sql = self._to_sql(
+                            exp.Update(
+                                this=table_name_without_catalog.copy(),
+                                expressions=[
+                                    exp.EQ(
+                                        this=temp_column_name.copy(),
+                                        expression=exp.Cast(
+                                            this=column_to_alter.copy(), to=new_type.copy()
+                                        ),
+                                    )
+                                ],
+                            )
+                        )
+                        self.execute(update_sql)
+
+                        # Step 3: Drop the original column.
+                        drop_sql = self._to_sql(
+                            exp.Alter(
+                                this=table_name_without_catalog.copy(),
+                                kind="TABLE",
+                                actions=[exp.Drop(this=column_to_alter.copy(), kind="COLUMN")],
+                            )
+                        )
+                        self.execute(drop_sql)
+
+                        # Step 4: Rename the temporary column.
+                        old_name_qualified = f"{table_name_without_catalog.sql(dialect=self.dialect)}.{temp_column_name.sql(dialect=self.dialect)}"
+                        new_name_unquoted = column_to_alter.sql(
+                            dialect=self.dialect, identify=False
+                        )
+                        rename_sql = f"EXEC sp_rename '{old_name_qualified}', '{new_name_unquoted}', 'COLUMN'"
+                        self.execute(rename_sql)
+                    else:
+                        # For other alterations, execute directly.
+                        direct_alter_expr = exp.Alter(
+                            this=table_name_without_catalog.copy(), kind="TABLE", actions=[action]
+                        )
+                        self.execute(direct_alter_expr)
+
 
 class FabricHttpClient:
     def __init__(self, tenant_id: str, workspace_id: str, client_id: str, client_secret: str):

sqlmesh/core/engine_adapter/trino.py

@@ -74,6 +74,32 @@ class TrinoEngineAdapter(
     def schema_location_mapping(self) -> t.Optional[t.Dict[re.Pattern, str]]:
         return self._extra_config.get("schema_location_mapping")
 
+    @property
+    def timestamp_mapping(self) -> t.Optional[t.Dict[exp.DataType, exp.DataType]]:
+        return self._extra_config.get("timestamp_mapping")
+
+    def _apply_timestamp_mapping(
+        self, columns_to_types: t.Dict[str, exp.DataType]
+    ) -> t.Tuple[t.Dict[str, exp.DataType], t.Set[str]]:
+        """Apply custom timestamp mapping to column types.
+
+        Returns:
+            A tuple of (mapped_columns_to_types, mapped_column_names) where mapped_column_names
+            contains the names of columns that were found in the mapping.
+        """
+        if not self.timestamp_mapping:
+            return columns_to_types, set()
+
+        result = {}
+        mapped_columns: t.Set[str] = set()
+        for column, column_type in columns_to_types.items():
+            if column_type in self.timestamp_mapping:
+                result[column] = self.timestamp_mapping[column_type]
+                mapped_columns.add(column)
+            else:
+                result[column] = column_type
+        return result, mapped_columns
+
     @property
     def catalog_support(self) -> CatalogSupport:
         return CatalogSupport.FULL_SUPPORT
@@ -117,7 +143,7 @@ class TrinoEngineAdapter(
         try:
             yield
         finally:
-            self.execute(f"RESET SESSION AUTHORIZATION")
+            self.execute("RESET SESSION AUTHORIZATION")
 
     def replace_query(
         self,
@@ -284,9 +310,13 @@ class TrinoEngineAdapter(
         column_descriptions: t.Optional[t.Dict[str, str]] = None,
         expressions: t.Optional[t.List[exp.PrimaryKey]] = None,
         is_view: bool = False,
+        materialized: bool = False,
     ) -> exp.Schema:
+        target_columns_to_types, mapped_columns = self._apply_timestamp_mapping(
+            target_columns_to_types
+        )
         if "delta_lake" in self.get_catalog_type_from_table(table):
-            target_columns_to_types = self._to_delta_ts(target_columns_to_types)
+            target_columns_to_types = self._to_delta_ts(target_columns_to_types, mapped_columns)
 
         return super()._build_schema_exp(
             table, target_columns_to_types, column_descriptions, expressions, is_view
@@ -312,10 +342,15 @@ class TrinoEngineAdapter(
         source_columns: t.Optional[t.List[str]] = None,
         **kwargs: t.Any,
     ) -> None:
+        mapped_columns: t.Set[str] = set()
+        if target_columns_to_types:
+            target_columns_to_types, mapped_columns = self._apply_timestamp_mapping(
+                target_columns_to_types
+            )
         if target_columns_to_types and "delta_lake" in self.get_catalog_type_from_table(
             target_table
         ):
-            target_columns_to_types = self._to_delta_ts(target_columns_to_types)
+            target_columns_to_types = self._to_delta_ts(target_columns_to_types, mapped_columns)
 
         return super()._scd_type_2(
             target_table,
@@ -345,18 +380,21 @@ class TrinoEngineAdapter(
     # - `timestamp(3) with time zone` for timezone-aware
     # https://trino.io/docs/current/connector/delta-lake.html#delta-lake-to-trino-type-mapping
     def _to_delta_ts(
-        self, columns_to_types: t.Dict[str, exp.DataType]
+        self,
+        columns_to_types: t.Dict[str, exp.DataType],
+        skip_columns: t.Optional[t.Set[str]] = None,
     ) -> t.Dict[str, exp.DataType]:
         ts6 = exp.DataType.build("timestamp(6)")
         ts3_tz = exp.DataType.build("timestamp(3) with time zone")
+        skip = skip_columns or set()
 
         delta_columns_to_types = {
-            k: ts6 if v.is_type(exp.DataType.Type.TIMESTAMP) else v
+            k: ts6 if k not in skip and v.is_type(exp.DataType.Type.TIMESTAMP) else v
             for k, v in columns_to_types.items()
         }
 
         delta_columns_to_types = {
-            k: ts3_tz if v.is_type(exp.DataType.Type.TIMESTAMPTZ) else v
+            k: ts3_tz if k not in skip and v.is_type(exp.DataType.Type.TIMESTAMPTZ) else v
             for k, v in delta_columns_to_types.items()
         }
 

sqlmesh/core/lineage.py

@@ -66,6 +66,7 @@ def lineage(
         scope=scope,
         trim_selects=trim_selects,
         dialect=model.dialect,
+        copy=False,
     )
 
 

sqlmesh/core/linter/rules/builtin.py

@@ -129,6 +129,21 @@ class NoMissingAudits(Rule):
             return self.violation()
 
 
+class NoMissingUnitTest(Rule):
+    """All models must have a unit test found in the tests/ directory yaml files"""
+
+    def check_model(self, model: Model) -> t.Optional[RuleViolation]:
+        #  External models cannot have unit tests
+        if isinstance(model, ExternalModel):
+            return None
+
+        if model.name not in self.context.models_with_tests:
+            return self.violation(
+                violation_msg=f"Model {model.name} is missing unit test(s). Please add in the tests/ directory."
+            )
+        return None
+
+
 class NoMissingExternalModels(Rule):
     """All external models must be registered in the external_models.yaml file"""