sqlmesh 0.217.1.dev1__py3-none-any.whl → 0.227.2.dev20__py3-none-any.whl

sqlmesh/core/engine_adapter/trino.py

@@ -71,7 +71,7 @@ class TrinoEngineAdapter(
     MAX_TIMESTAMP_PRECISION = 3
 
     @property
-    def schema_location_mapping(self) -> t.Optional[dict[re.Pattern, str]]:
+    def schema_location_mapping(self) -> t.Optional[t.Dict[re.Pattern, str]]:
         return self._extra_config.get("schema_location_mapping")
 
     @property
@@ -86,6 +86,8 @@ class TrinoEngineAdapter(
     def get_catalog_type(self, catalog: t.Optional[str]) -> str:
         row: t.Tuple = tuple()
         if catalog:
+            if catalog_type_override := self._catalog_type_overrides.get(catalog):
+                return catalog_type_override
             row = (
                 self.fetchone(
                     f"select connector_name from system.metadata.catalogs where catalog_name='{catalog}'"
@@ -282,6 +284,7 @@ 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:
         if "delta_lake" in self.get_catalog_type_from_table(table):
             target_columns_to_types = self._to_delta_ts(target_columns_to_types)
@@ -300,7 +303,7 @@ class TrinoEngineAdapter(
         execution_time: t.Union[TimeLike, exp.Column],
         invalidate_hard_deletes: bool = True,
         updated_at_col: t.Optional[exp.Column] = None,
-        check_columns: t.Optional[t.Union[exp.Star, t.Sequence[exp.Column]]] = None,
+        check_columns: t.Optional[t.Union[exp.Star, t.Sequence[exp.Expression]]] = None,
         updated_at_as_valid_from: bool = False,
         execution_time_as_valid_from: bool = False,
         target_columns_to_types: t.Optional[t.Dict[str, exp.DataType]] = None,

sqlmesh/core/janitor.py

@@ -0,0 +1,181 @@
+from __future__ import annotations
+
+import typing as t
+
+from sqlglot import exp
+
+from sqlmesh.core.engine_adapter import EngineAdapter
+from sqlmesh.core.console import Console
+from sqlmesh.core.dialect import schema_
+from sqlmesh.core.environment import Environment
+from sqlmesh.core.snapshot import SnapshotEvaluator
+from sqlmesh.core.state_sync import StateSync
+from sqlmesh.core.state_sync.common import (
+    logger,
+    iter_expired_snapshot_batches,
+    RowBoundary,
+    ExpiredBatchRange,
+)
+from sqlmesh.utils.errors import SQLMeshError
+
+
+def cleanup_expired_views(
+    default_adapter: EngineAdapter,
+    engine_adapters: t.Dict[str, EngineAdapter],
+    environments: t.List[Environment],
+    warn_on_delete_failure: bool = False,
+    console: t.Optional[Console] = None,
+) -> None:
+    expired_schema_or_catalog_environments = [
+        environment
+        for environment in environments
+        if environment.suffix_target.is_schema or environment.suffix_target.is_catalog
+    ]
+    expired_table_environments = [
+        environment for environment in environments if environment.suffix_target.is_table
+    ]
+
+    # We have to use the corresponding adapter if the virtual layer is gateway managed
+    def get_adapter(gateway_managed: bool, gateway: t.Optional[str] = None) -> EngineAdapter:
+        if gateway_managed and gateway:
+            return engine_adapters.get(gateway, default_adapter)
+        return default_adapter
+
+    catalogs_to_drop: t.Set[t.Tuple[EngineAdapter, str]] = set()
+    schemas_to_drop: t.Set[t.Tuple[EngineAdapter, exp.Table]] = set()
+
+    # Collect schemas and catalogs to drop
+    for engine_adapter, expired_catalog, expired_schema, suffix_target in {
+        (
+            (engine_adapter := get_adapter(environment.gateway_managed, snapshot.model_gateway)),
+            snapshot.qualified_view_name.catalog_for_environment(
+                environment.naming_info, dialect=engine_adapter.dialect
+            ),
+            snapshot.qualified_view_name.schema_for_environment(
+                environment.naming_info, dialect=engine_adapter.dialect
+            ),
+            environment.suffix_target,
+        )
+        for environment in expired_schema_or_catalog_environments
+        for snapshot in environment.snapshots
+        if snapshot.is_model and not snapshot.is_symbolic
+    }:
+        if suffix_target.is_catalog:
+            if expired_catalog:
+                catalogs_to_drop.add((engine_adapter, expired_catalog))
+        else:
+            schema = schema_(expired_schema, expired_catalog)
+            schemas_to_drop.add((engine_adapter, schema))
+
+    # Drop the views for the expired environments
+    for engine_adapter, expired_view in {
+        (
+            (engine_adapter := get_adapter(environment.gateway_managed, snapshot.model_gateway)),
+            snapshot.qualified_view_name.for_environment(
+                environment.naming_info, dialect=engine_adapter.dialect
+            ),
+        )
+        for environment in expired_table_environments
+        for snapshot in environment.snapshots
+        if snapshot.is_model and not snapshot.is_symbolic
+    }:
+        try:
+            engine_adapter.drop_view(expired_view, ignore_if_not_exists=True)
+            if console:
+                console.update_cleanup_progress(expired_view)
+        except Exception as e:
+            message = f"Failed to drop the expired environment view '{expired_view}': {e}"
+            if warn_on_delete_failure:
+                logger.warning(message)
+            else:
+                raise SQLMeshError(message) from e
+
+    # Drop the schemas for the expired environments
+    for engine_adapter, schema in schemas_to_drop:
+        try:
+            engine_adapter.drop_schema(
+                schema,
+                ignore_if_not_exists=True,
+                cascade=True,
+            )
+            if console:
+                console.update_cleanup_progress(schema.sql(dialect=engine_adapter.dialect))
+        except Exception as e:
+            message = f"Failed to drop the expired environment schema '{schema}': {e}"
+            if warn_on_delete_failure:
+                logger.warning(message)
+            else:
+                raise SQLMeshError(message) from e
+
+    # Drop any catalogs that were associated with a snapshot where the engine adapter supports dropping catalogs
+    # catalogs_to_drop is only populated when environment_suffix_target is set to 'catalog'
+    for engine_adapter, catalog in catalogs_to_drop:
+        if engine_adapter.SUPPORTS_CREATE_DROP_CATALOG:
+            try:
+                engine_adapter.drop_catalog(catalog)
+                if console:
+                    console.update_cleanup_progress(catalog)
+            except Exception as e:
+                message = f"Failed to drop the expired environment catalog '{catalog}': {e}"
+                if warn_on_delete_failure:
+                    logger.warning(message)
+                else:
+                    raise SQLMeshError(message) from e
+
+
+def delete_expired_snapshots(
+    state_sync: StateSync,
+    snapshot_evaluator: SnapshotEvaluator,
+    *,
+    current_ts: int,
+    ignore_ttl: bool = False,
+    batch_size: t.Optional[int] = None,
+    console: t.Optional[Console] = None,
+) -> None:
+    """Delete all expired snapshots in batches.
+
+    This helper function encapsulates the logic for deleting expired snapshots in batches,
+    eliminating code duplication across different use cases.
+
+    Args:
+        state_sync: StateSync instance to query and delete expired snapshots from.
+        snapshot_evaluator: SnapshotEvaluator instance to clean up tables associated with snapshots.
+        current_ts: Timestamp used to evaluate expiration.
+        ignore_ttl: If True, include snapshots regardless of TTL (only checks if unreferenced).
+        batch_size: Maximum number of snapshots to fetch per batch.
+        console: Optional console for reporting progress.
+
+    Returns:
+        The total number of deleted expired snapshots.
+    """
+    num_expired_snapshots = 0
+    for batch in iter_expired_snapshot_batches(
+        state_reader=state_sync,
+        current_ts=current_ts,
+        ignore_ttl=ignore_ttl,
+        batch_size=batch_size,
+    ):
+        end_info = (
+            f"updated_ts={batch.batch_range.end.updated_ts}"
+            if isinstance(batch.batch_range.end, RowBoundary)
+            else f"limit={batch.batch_range.end.batch_size}"
+        )
+        logger.info(
+            "Processing batch of size %s with end %s",
+            len(batch.expired_snapshot_ids),
+            end_info,
+        )
+        snapshot_evaluator.cleanup(
+            target_snapshots=batch.cleanup_tasks,
+            on_complete=console.update_cleanup_progress if console else None,
+        )
+        state_sync.delete_expired_snapshots(
+            batch_range=ExpiredBatchRange(
+                start=RowBoundary.lowest_boundary(),
+                end=batch.batch_range.end,
+            ),
+            ignore_ttl=ignore_ttl,
+        )
+        logger.info("Cleaned up expired snapshots batch")
+        num_expired_snapshots += len(batch.expired_snapshot_ids)
+    logger.info("Cleaned up %s expired snapshots", num_expired_snapshots)

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"""
 

sqlmesh/core/loader.py

@@ -35,7 +35,7 @@ from sqlmesh.core.model import (
 from sqlmesh.core.model import model as model_registry
 from sqlmesh.core.model.common import make_python_env
 from sqlmesh.core.signal import signal
-from sqlmesh.core.test import ModelTestMetadata, filter_tests_by_patterns
+from sqlmesh.core.test import ModelTestMetadata
 from sqlmesh.utils import UniqueKeyDict, sys_path
 from sqlmesh.utils.errors import ConfigError
 from sqlmesh.utils.jinja import JinjaMacroRegistry, MacroExtractor
@@ -64,6 +64,7 @@ class LoadedProject:
     excluded_requirements: t.Set[str]
     environment_statements: t.List[EnvironmentStatements]
     user_rules: RuleSet
+    model_test_metadata: t.List[ModelTestMetadata]
 
 
 class CacheBase(abc.ABC):
@@ -243,6 +244,8 @@ class Loader(abc.ABC):
 
             user_rules = self._load_linting_rules()
 
+            model_test_metadata = self.load_model_tests()
+
             project = LoadedProject(
                 macros=macros,
                 jinja_macros=jinja_macros,
@@ -254,6 +257,7 @@ class Loader(abc.ABC):
                 excluded_requirements=excluded_requirements,
                 environment_statements=environment_statements,
                 user_rules=user_rules,
+                model_test_metadata=model_test_metadata,
             )
             return project
 
@@ -423,9 +427,7 @@ class Loader(abc.ABC):
         """Loads user linting rules"""
         return RuleSet()
 
-    def load_model_tests(
-        self, tests: t.Optional[t.List[str]] = None, patterns: list[str] | None = None
-    ) -> t.List[ModelTestMetadata]:
+    def load_model_tests(self) -> t.List[ModelTestMetadata]:
         """Loads YAML-based model tests"""
         return []
 
@@ -864,38 +866,23 @@ class SqlMeshLoader(Loader):
 
         return model_test_metadata
 
-    def load_model_tests(
-        self, tests: t.Optional[t.List[str]] = None, patterns: list[str] | None = None
-    ) -> t.List[ModelTestMetadata]:
+    def load_model_tests(self) -> t.List[ModelTestMetadata]:
         """Loads YAML-based model tests"""
         test_meta_list: t.List[ModelTestMetadata] = []
 
-        if tests:
-            for test in tests:
-                filename, test_name = test.split("::", maxsplit=1) if "::" in test else (test, "")
-
-                test_meta = self._load_model_test_file(Path(filename))
-                if test_name:
-                    test_meta_list.append(test_meta[test_name])
-                else:
-                    test_meta_list.extend(test_meta.values())
-        else:
-            search_path = Path(self.config_path) / c.TESTS
+        search_path = Path(self.config_path) / c.TESTS
 
-            for yaml_file in itertools.chain(
-                search_path.glob("**/test*.yaml"),
-                search_path.glob("**/test*.yml"),
+        for yaml_file in itertools.chain(
+            search_path.glob("**/test*.yaml"),
+            search_path.glob("**/test*.yml"),
+        ):
+            if any(
+                yaml_file.match(ignore_pattern)
+                for ignore_pattern in self.config.ignore_patterns or []
             ):
-                if any(
-                    yaml_file.match(ignore_pattern)
-                    for ignore_pattern in self.config.ignore_patterns or []
-                ):
-                    continue
-
-                test_meta_list.extend(self._load_model_test_file(yaml_file).values())
+                continue
 
-        if patterns:
-            test_meta_list = filter_tests_by_patterns(test_meta_list, patterns)
+            test_meta_list.extend(self._load_model_test_file(yaml_file).values())
 
         return test_meta_list
 

sqlmesh/core/macros.py

@@ -128,6 +128,17 @@ def _macro_str_replace(text: str) -> str:
     return f"self.template({text}, locals())"
 
 
+class CaseInsensitiveMapping(t.Dict[str, t.Any]):
+    def __init__(self, data: t.Dict[str, t.Any]) -> None:
+        super().__init__(data)
+
+    def __getitem__(self, key: str) -> t.Any:
+        return super().__getitem__(key.lower())
+
+    def get(self, key: str, default: t.Any = None, /) -> t.Any:
+        return super().get(key.lower(), default)
+
+
 class MacroDialect(Python):
     class Generator(Python.Generator):
         TRANSFORMS = {
@@ -256,14 +267,18 @@ class MacroEvaluator:
                 changed = True
                 variables = self.variables
 
-                if node.name not in self.locals and node.name.lower() not in variables:
+                # This makes all variables case-insensitive, e.g. @X is the same as @x. We do this
+                # for consistency, since `variables` and `blueprint_variables` are normalized.
+                var_name = node.name.lower()
+
+                if var_name not in self.locals and var_name not in variables:
                     if not isinstance(node.parent, StagedFilePath):
                         raise SQLMeshError(f"Macro variable '{node.name}' is undefined.")
 
                     return node
 
                 # Precedence order is locals (e.g. @DEF) > blueprint variables > config variables
-                value = self.locals.get(node.name, variables.get(node.name.lower()))
+                value = self.locals.get(var_name, variables.get(var_name))
                 if isinstance(value, list):
                     return exp.convert(
                         tuple(
@@ -313,11 +328,16 @@ class MacroEvaluator:
         """
         # We try to convert all variables into sqlglot expressions because they're going to be converted
         # into strings; in sql we don't convert strings because that would result in adding quotes
-        mapping = {
-            k: convert_sql(v, self.dialect)
+        base_mapping = {
+            k.lower(): convert_sql(v, self.dialect)
             for k, v in chain(self.variables.items(), self.locals.items(), local_variables.items())
+            if k.lower()
+            not in (
+                "engine_adapter",
+                "snapshot",
+            )
         }
-        return MacroStrTemplate(str(text)).safe_substitute(mapping)
+        return MacroStrTemplate(str(text)).safe_substitute(CaseInsensitiveMapping(base_mapping))
 
     def evaluate(self, node: MacroFunc) -> exp.Expression | t.List[exp.Expression] | None:
         if isinstance(node, MacroDef):
@@ -327,7 +347,9 @@ class MacroEvaluator:
                     args[0] if len(args) == 1 else exp.Tuple(expressions=list(args))
                 )
             else:
-                self.locals[node.name] = self.transform(node.expression)
+                # Make variables defined through `@DEF` case-insensitive
+                self.locals[node.name.lower()] = self.transform(node.expression)
+
             return node
 
         if isinstance(node, (MacroSQL, MacroStrReplace)):
@@ -630,7 +652,7 @@ def _norm_var_arg_lambda(
     ) -> exp.Expression | t.List[exp.Expression] | None:
         if isinstance(node, (exp.Identifier, exp.Var)):
             if not isinstance(node.parent, exp.Column):
-                name = node.name
+                name = node.name.lower()
                 if name in args:
                     return args[name].copy()
                 if name in evaluator.locals:
@@ -663,7 +685,7 @@ def _norm_var_arg_lambda(
         return expressions, lambda args: func.this.transform(
             substitute,
             {
-                expression.name: arg
+                expression.name.lower(): arg
                 for expression, arg in zip(
                     func.expressions, args.expressions if isinstance(args, exp.Tuple) else [args]
                 )
@@ -1128,7 +1150,7 @@ def haversine_distance(
 def pivot(
     evaluator: MacroEvaluator,
     column: SQL,
-    values: t.List[SQL],
+    values: t.List[exp.Expression],
     alias: bool = True,
     agg: exp.Expression = exp.Literal.string("SUM"),
     cmp: exp.Expression = exp.Literal.string("="),
@@ -1146,10 +1168,10 @@ def pivot(
         >>> from sqlmesh.core.macros import MacroEvaluator
         >>> sql = "SELECT date_day, @PIVOT(status, ['cancelled', 'completed']) FROM rides GROUP BY 1"
         >>> MacroEvaluator().transform(parse_one(sql)).sql()
-        'SELECT date_day, SUM(CASE WHEN status = \\'cancelled\\' THEN 1 ELSE 0 END) AS "\\'cancelled\\'", SUM(CASE WHEN status = \\'completed\\' THEN 1 ELSE 0 END) AS "\\'completed\\'" FROM rides GROUP BY 1'
+        'SELECT date_day, SUM(CASE WHEN status = \\'cancelled\\' THEN 1 ELSE 0 END) AS "cancelled", SUM(CASE WHEN status = \\'completed\\' THEN 1 ELSE 0 END) AS "completed" FROM rides GROUP BY 1'
         >>> sql = "SELECT @PIVOT(a, ['v'], then_value := tv, suffix := '_sfx', quote := FALSE)"
         >>> MacroEvaluator(dialect="bigquery").transform(parse_one(sql)).sql("bigquery")
-        "SELECT SUM(CASE WHEN a = 'v' THEN tv ELSE 0 END) AS `v_sfx`"
+        "SELECT SUM(CASE WHEN a = 'v' THEN tv ELSE 0 END) AS v_sfx"
     """
     aggregates: t.List[exp.Expression] = []
     for value in values:
@@ -1157,12 +1179,12 @@ def pivot(
         if distinct:
             proj += "DISTINCT "
 
-        proj += f"CASE WHEN {column} {cmp.name} {value} THEN {then_value} ELSE {else_value} END) "
+        proj += f"CASE WHEN {column} {cmp.name} {value.sql(evaluator.dialect)} THEN {then_value} ELSE {else_value} END) "
         node = evaluator.parse_one(proj)
 
         if alias:
             node = node.as_(
-                f"{prefix.name}{value}{suffix.name}",
+                f"{prefix.name}{value.name}{suffix.name}",
                 quoted=quote,
                 copy=False,
                 dialect=evaluator.dialect,

sqlmesh/core/model/common.py

@@ -641,6 +641,7 @@ properties_validator: t.Callable = field_validator(
     "physical_properties_",
     "virtual_properties_",
     "materialization_properties_",
+    "grants_",
     mode="before",
     check_fields=False,
 )(parse_properties)
@@ -662,6 +663,7 @@ depends_on_validator: t.Callable = field_validator(
 
 class ParsableSql(PydanticModel):
     sql: str
+    transaction: t.Optional[bool] = None
 
     _parsed: t.Optional[exp.Expression] = None
     _parsed_dialect: t.Optional[str] = None

sqlmesh/core/model/definition.py

@@ -67,6 +67,7 @@ if t.TYPE_CHECKING:
     from sqlmesh.core.context import ExecutionContext
     from sqlmesh.core.engine_adapter import EngineAdapter
     from sqlmesh.core.engine_adapter._typing import QueryOrDF
+    from sqlmesh.core.engine_adapter.shared import DataObjectType
     from sqlmesh.core.linter.rule import Rule
     from sqlmesh.core.snapshot import DeployabilityIndex, Node, Snapshot
     from sqlmesh.utils.jinja import MacroReference
@@ -362,6 +363,7 @@ class _Model(ModelMeta, frozen=True):
         expand: t.Iterable[str] = tuple(),
         deployability_index: t.Optional[DeployabilityIndex] = None,
         engine_adapter: t.Optional[EngineAdapter] = None,
+        inside_transaction: t.Optional[bool] = True,
         **kwargs: t.Any,
     ) -> t.List[exp.Expression]:
         """Renders pre-statements for a model.
@@ -383,7 +385,11 @@ class _Model(ModelMeta, frozen=True):
             The list of rendered expressions.
         """
         return self._render_statements(
-            self.pre_statements,
+            [
+                stmt
+                for stmt in self.pre_statements
+                if stmt.args.get("transaction", True) == inside_transaction
+            ],
             start=start,
             end=end,
             execution_time=execution_time,
@@ -404,6 +410,7 @@ class _Model(ModelMeta, frozen=True):
         expand: t.Iterable[str] = tuple(),
         deployability_index: t.Optional[DeployabilityIndex] = None,
         engine_adapter: t.Optional[EngineAdapter] = None,
+        inside_transaction: t.Optional[bool] = True,
         **kwargs: t.Any,
     ) -> t.List[exp.Expression]:
         """Renders post-statements for a model.
@@ -419,13 +426,18 @@ class _Model(ModelMeta, frozen=True):
                 that depend on materialized tables.  Model definitions are inlined and can thus be run end to
                 end on the fly.
             deployability_index: Determines snapshots that are deployable in the context of this render.
+            inside_transaction: Whether to render hooks with transaction=True (inside) or transaction=False (outside).
             kwargs: Additional kwargs to pass to the renderer.
 
         Returns:
             The list of rendered expressions.
         """
         return self._render_statements(
-            self.post_statements,
+            [
+                stmt
+                for stmt in self.post_statements
+                if stmt.args.get("transaction", True) == inside_transaction
+            ],
             start=start,
             end=end,
             execution_time=execution_time,
@@ -566,6 +578,8 @@ class _Model(ModelMeta, frozen=True):
         result = []
         for v in value:
             parsed = v.parse(self.dialect)
+            if getattr(v, "transaction", None) is not None:
+                parsed.set("transaction", v.transaction)
             if not isinstance(parsed, exp.Semicolon):
                 result.append(parsed)
         return result
@@ -1021,6 +1035,13 @@ class _Model(ModelMeta, frozen=True):
             # Will raise if the custom materialization points to an invalid class
             get_custom_materialization_type_or_raise(self.kind.materialization)
 
+        # Embedded model kind shouldn't have audits
+        if self.kind.name == ModelKindName.EMBEDDED and self.audits:
+            raise_config_error(
+                "Audits are not supported for embedded models",
+                self._path,
+            )
+
     def is_breaking_change(self, previous: Model) -> t.Optional[bool]:
         """Determines whether this model is a breaking change in relation to the `previous` model.
 
@@ -1186,6 +1207,8 @@ class _Model(ModelMeta, frozen=True):
                 gen(self.session_properties_) if self.session_properties_ else None,
                 *[gen(g) for g in self.grains],
                 *self._audit_metadata_hash_values(),
+                json.dumps(self.grants, sort_keys=True) if self.grants else None,
+                self.grants_target_layer,
             ]
 
             for key, value in (self.virtual_properties or {}).items():
@@ -1197,6 +1220,9 @@ class _Model(ModelMeta, frozen=True):
                 for k, v in sorted(args.items()):
                     metadata.append(f"{k}:{gen(v)}")
 
+            if self.dbt_node_info:
+                metadata.append(self.dbt_node_info.json(sort_keys=True))
+
             metadata.extend(self._additional_metadata)
 
             self._metadata_hash = hash_data(metadata)
@@ -1207,6 +1233,24 @@ class _Model(ModelMeta, frozen=True):
         """Return True if this is a model node"""
         return True
 
+    @property
+    def grants_table_type(self) -> DataObjectType:
+        """Get the table type for grants application (TABLE, VIEW, MATERIALIZED_VIEW).
+
+        Returns:
+            The DataObjectType that should be used when applying grants to this model.
+        """
+        from sqlmesh.core.engine_adapter.shared import DataObjectType
+
+        if self.kind.is_view:
+            if hasattr(self.kind, "materialized") and getattr(self.kind, "materialized", False):
+                return DataObjectType.MATERIALIZED_VIEW
+            return DataObjectType.VIEW
+        if self.kind.is_managed:
+            return DataObjectType.MANAGED_TABLE
+        # All other materialized models are tables
+        return DataObjectType.TABLE
+
     @property
     def _additional_metadata(self) -> t.List[str]:
         additional_metadata = []
@@ -1820,6 +1864,12 @@ class SeedModel(_Model):
         for column_name, column_hash in self.column_hashes.items():
             data.append(column_name)
             data.append(column_hash)
+
+        # Include grants in data hash for seed models to force recreation on grant changes
+        # since seed models don't support migration
+        data.append(json.dumps(self.grants, sort_keys=True) if self.grants else "")
+        data.append(self.grants_target_layer)
+
         return data
 
 
@@ -2562,9 +2612,17 @@ def _create_model(
         if statement_field in kwargs:
             # Macros extracted from these statements need to be treated as metadata only
             is_metadata = statement_field == "on_virtual_update"
-            statements.extend((stmt, is_metadata) for stmt in kwargs[statement_field])
+            for stmt in kwargs[statement_field]:
+                # Extract the expression if it's ParsableSql already
+                expr = stmt.parse(dialect) if isinstance(stmt, ParsableSql) else stmt
+                statements.append((expr, is_metadata))
             kwargs[statement_field] = [
-                ParsableSql.from_parsed_expression(stmt, dialect, use_meta_sql=use_original_sql)
+                # this to retain the transaction information
+                stmt
+                if isinstance(stmt, ParsableSql)
+                else ParsableSql.from_parsed_expression(
+                    stmt, dialect, use_meta_sql=use_original_sql
+                )
                 for stmt in kwargs[statement_field]
             ]
 
@@ -2866,6 +2924,13 @@ def render_meta_fields(
             for key, value in field_value.items():
                 if key in RUNTIME_RENDERED_MODEL_FIELDS:
                     rendered_dict[key] = parse_strings_with_macro_refs(value, dialect)
+                elif (
+                    # don't parse kind auto_restatement_cron="@..." kwargs (e.g. @daily) into MacroVar
+                    key == "auto_restatement_cron"
+                    and isinstance(value, str)
+                    and value.lower() in CRON_SHORTCUTS
+                ):
+                    rendered_dict[key] = value
                 elif (rendered := render_field_value(value)) is not None:
                     rendered_dict[key] = rendered
 
@@ -3012,6 +3077,9 @@ META_FIELD_CONVERTER: t.Dict[str, t.Callable] = {
     "formatting": str,
     "optimize_query": str,
     "virtual_environment_mode": lambda value: exp.Literal.string(value.value),
+    "dbt_node_info_": lambda value: value.to_expression(),
+    "grants_": lambda value: value,
+    "grants_target_layer": lambda value: exp.Literal.string(value.value),
 }