sqlmesh 0.212.1.dev3__tar.gz → 0.212.1.dev4__tar.gz

{sqlmesh-0.212.1.dev3 → sqlmesh-0.212.1.dev4}/PKG-INFO

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

{sqlmesh-0.212.1.dev3 → sqlmesh-0.212.1.dev4}/sqlmesh/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.212.1.dev3'
-__version_tuple__ = version_tuple = (0, 212, 1, 'dev3')
+__version__ = version = '0.212.1.dev4'
+__version_tuple__ = version_tuple = (0, 212, 1, 'dev4')
 
-__commit_id__ = commit_id = 'g454e942fe'
+__commit_id__ = commit_id = 'g75f825e9f'

{sqlmesh-0.212.1.dev3 → sqlmesh-0.212.1.dev4}/sqlmesh/core/audit/definition.py

@@ -15,11 +15,10 @@ from sqlmesh.core.model.common import (
     bool_validator,
     default_catalog_validator,
     depends_on_validator,
-    expression_validator,
     sort_python_env,
     sorted_python_env_payloads,
 )
-from sqlmesh.core.model.common import make_python_env, single_value_or_tuple
+from sqlmesh.core.model.common import make_python_env, single_value_or_tuple, ParsableSql
 from sqlmesh.core.node import _Node
 from sqlmesh.core.renderer import QueryRenderer
 from sqlmesh.utils.date import TimeLike
@@ -67,15 +66,26 @@ class AuditMixin(AuditCommonMetaMixin):
         jinja_macros: A registry of jinja macros to use when rendering the audit query.
     """
 
-    query: t.Union[exp.Query, d.JinjaQuery]
+    query_: ParsableSql
     defaults: t.Dict[str, exp.Expression]
-    expressions_: t.Optional[t.List[exp.Expression]]
+    expressions_: t.Optional[t.List[ParsableSql]]
     jinja_macros: JinjaMacroRegistry
     formatting: t.Optional[bool]
 
+    @property
+    def query(self) -> t.Union[exp.Query, d.JinjaQuery]:
+        return t.cast(t.Union[exp.Query, d.JinjaQuery], self.query_.parse(self.dialect))
+
     @property
     def expressions(self) -> t.List[exp.Expression]:
-        return self.expressions_ or []
+        if not self.expressions_:
+            return []
+        result = []
+        for e in self.expressions_:
+            parsed = e.parse(self.dialect)
+            if not isinstance(parsed, exp.Semicolon):
+                result.append(parsed)
+        return result
 
     @property
     def macro_definitions(self) -> t.List[d.MacroDef]:
@@ -122,16 +132,16 @@ class ModelAudit(PydanticModel, AuditMixin, frozen=True):
     skip: bool = False
     blocking: bool = True
     standalone: t.Literal[False] = False
-    query: t.Union[exp.Query, d.JinjaQuery]
+    query_: ParsableSql = Field(alias="query")
     defaults: t.Dict[str, exp.Expression] = {}
-    expressions_: t.Optional[t.List[exp.Expression]] = Field(default=None, alias="expressions")
+    expressions_: t.Optional[t.List[ParsableSql]] = Field(default=None, alias="expressions")
     jinja_macros: JinjaMacroRegistry = JinjaMacroRegistry()
     formatting: t.Optional[bool] = Field(default=None, exclude=True)
 
     _path: t.Optional[Path] = None
 
     # Validators
-    _query_validator = expression_validator
+    _query_validator = ParsableSql.validator()
     _bool_validator = bool_validator
     _string_validator = audit_string_validator
     _map_validator = audit_map_validator
@@ -153,9 +163,9 @@ class StandaloneAudit(_Node, AuditMixin):
     skip: bool = False
     blocking: bool = False
     standalone: t.Literal[True] = True
-    query: t.Union[exp.Query, d.JinjaQuery]
+    query_: ParsableSql = Field(alias="query")
     defaults: t.Dict[str, exp.Expression] = {}
-    expressions_: t.Optional[t.List[exp.Expression]] = Field(default=None, alias="expressions")
+    expressions_: t.Optional[t.List[ParsableSql]] = Field(default=None, alias="expressions")
     jinja_macros: JinjaMacroRegistry = JinjaMacroRegistry()
     default_catalog: t.Optional[str] = None
     depends_on_: t.Optional[t.Set[str]] = Field(default=None, alias="depends_on")
@@ -165,7 +175,7 @@ class StandaloneAudit(_Node, AuditMixin):
     source_type: t.Literal["audit"] = "audit"
 
     # Validators
-    _query_validator = expression_validator
+    _query_validator = ParsableSql.validator()
     _bool_validator = bool_validator
     _string_validator = audit_string_validator
     _map_validator = audit_map_validator
@@ -276,8 +286,8 @@ class StandaloneAudit(_Node, AuditMixin):
                 self.cron_tz.key if self.cron_tz else None,
             ]
 
-            query = self.render_audit_query() or self.query
-            data.append(gen(query))
+            data.append(self.query_.sql)
+            data.extend([e.sql for e in self.expressions_ or []])
             self._metadata_hash = hash_data(data)
         return self._metadata_hash
 
@@ -461,11 +471,17 @@ def load_audit(
         if project is not None:
             extra_kwargs["project"] = project
 
-    dialect = meta_fields.pop("dialect", dialect)
+    dialect = meta_fields.pop("dialect", dialect) or ""
+
+    parsable_query = ParsableSql.from_parsed_expression(query, dialect, use_meta_sql=True)
+    parsable_statements = [
+        ParsableSql.from_parsed_expression(s, dialect, use_meta_sql=True) for s in statements
+    ]
+
     try:
         audit = audit_class(
-            query=query,
-            expressions=statements,
+            query=parsable_query,
+            expressions=parsable_statements,
             dialect=dialect,
             **extra_kwargs,
             **meta_fields,

{sqlmesh-0.212.1.dev3 → sqlmesh-0.212.1.dev4}/sqlmesh/core/context_diff.py

@@ -435,7 +435,7 @@ class ContextDiff(PydanticModel):
             return False
 
         current, previous = self.modified_snapshots[name]
-        return current.fingerprint.data_hash != previous.fingerprint.data_hash
+        return current.is_directly_modified(previous)
 
     def indirectly_modified(self, name: str) -> bool:
         """Returns whether or not a node was indirectly modified in this context.
@@ -451,10 +451,7 @@ class ContextDiff(PydanticModel):
             return False
 
         current, previous = self.modified_snapshots[name]
-        return (
-            current.fingerprint.data_hash == previous.fingerprint.data_hash
-            and current.fingerprint.parent_data_hash != previous.fingerprint.parent_data_hash
-        )
+        return current.is_indirectly_modified(previous)
 
     def metadata_updated(self, name: str) -> bool:
         """Returns whether or not the given node's metadata has been updated.
@@ -470,7 +467,7 @@ class ContextDiff(PydanticModel):
             return False
 
         current, previous = self.modified_snapshots[name]
-        return current.fingerprint.metadata_hash != previous.fingerprint.metadata_hash
+        return current.is_metadata_updated(previous)
 
     def text_diff(self, name: str) -> str:
         """Finds the difference of a node between the current and remote environment.

{sqlmesh-0.212.1.dev3 → sqlmesh-0.212.1.dev4}/sqlmesh/core/model/common.py

@@ -21,7 +21,7 @@ from sqlmesh.utils.metaprogramming import (
     prepare_env,
     serialize_env,
 )
-from sqlmesh.utils.pydantic import PydanticModel, ValidationInfo, field_validator
+from sqlmesh.utils.pydantic import PydanticModel, ValidationInfo, field_validator, get_dialect
 
 if t.TYPE_CHECKING:
     from sqlglot.dialects.dialect import DialectType
@@ -616,11 +616,6 @@ def parse_strings_with_macro_refs(value: t.Any, dialect: DialectType) -> t.Any:
 
 
 expression_validator: t.Callable = field_validator(
-    "query",
-    "expressions_",
-    "pre_statements_",
-    "post_statements_",
-    "on_virtual_update_",
     "unique_key",
     mode="before",
     check_fields=False,
@@ -663,3 +658,65 @@ depends_on_validator: t.Callable = field_validator(
     mode="before",
     check_fields=False,
 )(depends_on)
+
+
+class ParsableSql(PydanticModel):
+    sql: str
+
+    _parsed: t.Optional[exp.Expression] = None
+    _parsed_dialect: t.Optional[str] = None
+
+    def parse(self, dialect: str) -> exp.Expression:
+        if self._parsed is None or self._parsed_dialect != dialect:
+            self._parsed = d.parse_one(self.sql, dialect=dialect)
+            self._parsed_dialect = dialect
+        return self._parsed
+
+    @classmethod
+    def from_parsed_expression(
+        cls, parsed_expression: exp.Expression, dialect: str, use_meta_sql: bool = False
+    ) -> ParsableSql:
+        sql = (
+            parsed_expression.meta.get("sql") or parsed_expression.sql(dialect=dialect)
+            if use_meta_sql
+            else parsed_expression.sql(dialect=dialect)
+        )
+        result = cls(sql=sql)
+        result._parsed = parsed_expression
+        result._parsed_dialect = dialect
+        return result
+
+    @classmethod
+    def validator(cls) -> classmethod:
+        def _validate_parsable_sql(
+            v: t.Any, info: ValidationInfo
+        ) -> t.Optional[t.Union[ParsableSql, t.List[ParsableSql]]]:
+            if v is None:
+                return v
+            if isinstance(v, str):
+                return ParsableSql(sql=v)
+            if isinstance(v, exp.Expression):
+                return ParsableSql.from_parsed_expression(
+                    v, get_dialect(info.data), use_meta_sql=False
+                )
+            if isinstance(v, list):
+                dialect = get_dialect(info.data)
+                return [
+                    ParsableSql(sql=s)
+                    if isinstance(s, str)
+                    else ParsableSql.from_parsed_expression(s, dialect, use_meta_sql=False)
+                    if isinstance(s, exp.Expression)
+                    else ParsableSql.parse_obj(s)
+                    for s in v
+                ]
+            return ParsableSql.parse_obj(v)
+
+        return field_validator(
+            "query_",
+            "expressions_",
+            "pre_statements_",
+            "post_statements_",
+            "on_virtual_update_",
+            mode="before",
+            check_fields=False,
+        )(_validate_parsable_sql)

{sqlmesh-0.212.1.dev3 → sqlmesh-0.212.1.dev4}/sqlmesh/core/model/definition.py

@@ -24,7 +24,7 @@ from sqlmesh.core.audit import Audit, ModelAudit
 from sqlmesh.core.node import IntervalUnit
 from sqlmesh.core.macros import MacroRegistry, macro
 from sqlmesh.core.model.common import (
-    expression_validator,
+    ParsableSql,
     make_python_env,
     parse_dependencies,
     parse_strings_with_macro_refs,
@@ -62,6 +62,7 @@ from sqlmesh.utils.metaprogramming import (
 
 if t.TYPE_CHECKING:
     from sqlglot.dialects.dialect import DialectType
+    from sqlmesh.core.node import _Node
     from sqlmesh.core._typing import Self, TableName, SessionProperties
     from sqlmesh.core.context import ExecutionContext
     from sqlmesh.core.engine_adapter import EngineAdapter
@@ -150,21 +151,17 @@ class _Model(ModelMeta, frozen=True):
     audit_definitions: t.Dict[str, ModelAudit] = {}
     mapping_schema: t.Dict[str, t.Any] = {}
     extract_dependencies_from_query: bool = True
+    pre_statements_: t.Optional[t.List[ParsableSql]] = Field(default=None, alias="pre_statements")
+    post_statements_: t.Optional[t.List[ParsableSql]] = Field(default=None, alias="post_statements")
+    on_virtual_update_: t.Optional[t.List[ParsableSql]] = Field(
+        default=None, alias="on_virtual_update"
+    )
 
     _full_depends_on: t.Optional[t.Set[str]] = None
     _statement_renderer_cache: t.Dict[int, ExpressionRenderer] = {}
+    _is_metadata_only_change_cache: t.Dict[int, bool] = {}
 
-    pre_statements_: t.Optional[t.List[exp.Expression]] = Field(
-        default=None, alias="pre_statements"
-    )
-    post_statements_: t.Optional[t.List[exp.Expression]] = Field(
-        default=None, alias="post_statements"
-    )
-    on_virtual_update_: t.Optional[t.List[exp.Expression]] = Field(
-        default=None, alias="on_virtual_update"
-    )
-
-    _expressions_validator = expression_validator
+    _expressions_validator = ParsableSql.validator()
 
     def __getstate__(self) -> t.Dict[t.Any, t.Any]:
         state = super().__getstate__()
@@ -543,15 +540,15 @@ class _Model(ModelMeta, frozen=True):
 
     @property
     def pre_statements(self) -> t.List[exp.Expression]:
-        return self.pre_statements_ or []
+        return self._get_parsed_statements("pre_statements_")
 
     @property
     def post_statements(self) -> t.List[exp.Expression]:
-        return self.post_statements_ or []
+        return self._get_parsed_statements("post_statements_")
 
     @property
     def on_virtual_update(self) -> t.List[exp.Expression]:
-        return self.on_virtual_update_ or []
+        return self._get_parsed_statements("on_virtual_update_")
 
     @property
     def macro_definitions(self) -> t.List[d.MacroDef]:
@@ -562,6 +559,17 @@ class _Model(ModelMeta, frozen=True):
             if isinstance(s, d.MacroDef)
         ]
 
+    def _get_parsed_statements(self, attr_name: str) -> t.List[exp.Expression]:
+        value = getattr(self, attr_name)
+        if not value:
+            return []
+        result = []
+        for v in value:
+            parsed = v.parse(self.dialect)
+            if not isinstance(parsed, exp.Semicolon):
+                result.append(parsed)
+        return result
+
     def _render_statements(
         self,
         statements: t.Iterable[exp.Expression],
@@ -1025,6 +1033,45 @@ class _Model(ModelMeta, frozen=True):
         """
         raise NotImplementedError
 
+    def is_metadata_only_change(self, other: _Node) -> bool:
+        if self._is_metadata_only_change_cache.get(id(other), None) is not None:
+            return self._is_metadata_only_change_cache[id(other)]
+
+        is_metadata_change = True
+        if (
+            not isinstance(other, _Model)
+            or self.metadata_hash == other.metadata_hash
+            or self._data_hash_values_no_sql != other._data_hash_values_no_sql
+        ):
+            is_metadata_change = False
+        else:
+            this_statements = [
+                s
+                for s in [*self.pre_statements, *self.post_statements]
+                if not self._is_metadata_statement(s)
+            ]
+            other_statements = [
+                s
+                for s in [*other.pre_statements, *other.post_statements]
+                if not other._is_metadata_statement(s)
+            ]
+            if len(this_statements) != len(other_statements):
+                is_metadata_change = False
+            else:
+                for this_statement, other_statement in zip(this_statements, other_statements):
+                    this_rendered = (
+                        self._statement_renderer(this_statement).render() or this_statement
+                    )
+                    other_rendered = (
+                        other._statement_renderer(other_statement).render() or other_statement
+                    )
+                    if this_rendered != other_rendered:
+                        is_metadata_change = False
+                        break
+
+        self._is_metadata_only_change_cache[id(other)] = is_metadata_change
+        return is_metadata_change
+
     @property
     def data_hash(self) -> str:
         """
@@ -1039,6 +1086,20 @@ class _Model(ModelMeta, frozen=True):
 
     @property
     def _data_hash_values(self) -> t.List[str]:
+        return self._data_hash_values_no_sql + self._data_hash_values_sql
+
+    @property
+    def _data_hash_values_sql(self) -> t.List[str]:
+        data = []
+
+        for statements in [self.pre_statements_, self.post_statements_]:
+            for statement in statements or []:
+                data.append(statement.sql)
+
+        return data
+
+    @property
+    def _data_hash_values_no_sql(self) -> t.List[str]:
         data = [
             str(  # Exclude metadata only macro funcs
                 [(k, v) for k, v in self.sorted_python_env if not v.is_metadata]
@@ -1066,18 +1127,6 @@ class _Model(ModelMeta, frozen=True):
             data.append(key)
             data.append(gen(value))
 
-        for statement in (*self.pre_statements, *self.post_statements):
-            statement_exprs: t.List[exp.Expression] = []
-            if not isinstance(statement, d.MacroDef):
-                rendered = self._statement_renderer(statement).render()
-                if self._is_metadata_statement(statement):
-                    continue
-                if rendered:
-                    statement_exprs = rendered
-                else:
-                    statement_exprs = [statement]
-            data.extend(gen(e) for e in statement_exprs)
-
         return data  # type: ignore
 
     def _audit_metadata_hash_values(self) -> t.List[str]:
@@ -1093,13 +1142,9 @@ class _Model(ModelMeta, frozen=True):
                     metadata.append(gen(arg_value))
             else:
                 audit = self.audit_definitions[audit_name]
-                query = (
-                    self.render_audit_query(audit, **t.cast(t.Dict[str, t.Any], audit_args))
-                    or audit.query
-                )
                 metadata.extend(
                     [
-                        gen(query),
+                        audit.query_.sql,
                         audit.dialect,
                         str(audit.skip),
                         str(audit.blocking),
@@ -1170,12 +1215,9 @@ class _Model(ModelMeta, frozen=True):
         if metadata_only_macros:
             additional_metadata.append(str(metadata_only_macros))
 
-        for statement in (*self.pre_statements, *self.post_statements):
-            if self._is_metadata_statement(statement):
-                additional_metadata.append(gen(statement))
-
-        for statement in self.on_virtual_update:
-            additional_metadata.append(gen(statement))
+        for statements in [self.pre_statements_, self.post_statements_, self.on_virtual_update_]:
+            for statement in statements or []:
+                additional_metadata.append(statement.sql)
 
         return additional_metadata
 
@@ -1274,7 +1316,7 @@ class SqlModel(_Model):
         on_virtual_update: The list of SQL statements to be executed after the virtual update.
     """
 
-    query: t.Union[exp.Query, d.JinjaQuery, d.MacroFunc]
+    query_: ParsableSql = Field(alias="query")
     source_type: t.Literal["sql"] = "sql"
 
     _columns_to_types: t.Optional[t.Dict[str, exp.DataType]] = None
@@ -1298,6 +1340,11 @@ class SqlModel(_Model):
             model._full_depends_on = None
         return model
 
+    @property
+    def query(self) -> t.Union[exp.Query, d.JinjaQuery, d.MacroFunc]:
+        parsed_query = self.query_.parse(self.dialect)
+        return t.cast(t.Union[exp.Query, d.JinjaQuery, d.MacroFunc], parsed_query)
+
     def render_query(
         self,
         *,
@@ -1500,6 +1547,24 @@ class SqlModel(_Model):
 
         return False
 
+    def is_metadata_only_change(self, previous: _Node) -> bool:
+        if self._is_metadata_only_change_cache.get(id(previous), None) is not None:
+            return self._is_metadata_only_change_cache[id(previous)]
+
+        if not super().is_metadata_only_change(previous):
+            return False
+
+        if not isinstance(previous, SqlModel):
+            self._is_metadata_only_change_cache[id(previous)] = False
+            return False
+
+        this_rendered_query = self.render_query() or self.query
+        previous_rendered_query = previous.render_query() or previous.query
+        is_metadata_change = this_rendered_query == previous_rendered_query
+
+        self._is_metadata_only_change_cache[id(previous)] = is_metadata_change
+        return is_metadata_change
+
     @cached_property
     def _query_renderer(self) -> QueryRenderer:
         no_quote_identifiers = self.kind.is_view and self.dialect in ("trino", "spark")
@@ -1519,17 +1584,22 @@ class SqlModel(_Model):
         )
 
     @property
-    def _data_hash_values(self) -> t.List[str]:
-        data = super()._data_hash_values
+    def _data_hash_values_no_sql(self) -> t.List[str]:
+        return [
+            *super()._data_hash_values_no_sql,
+            *self.jinja_macros.data_hash_values,
+        ]
 
-        query = self.render_query() or self.query
-        data.append(gen(query))
-        data.extend(self.jinja_macros.data_hash_values)
-        return data
+    @property
+    def _data_hash_values_sql(self) -> t.List[str]:
+        return [
+            *super()._data_hash_values_sql,
+            self.query_.sql,
+        ]
 
     @property
     def _additional_metadata(self) -> t.List[str]:
-        return [*super()._additional_metadata, gen(self.query)]
+        return [*super()._additional_metadata, self.query_.sql]
 
     @property
     def violated_rules_for_query(self) -> t.Dict[type[Rule], t.Any]:
@@ -1753,8 +1823,8 @@ class SeedModel(_Model):
         return self.seed.reader(dialect=self.dialect, settings=self.kind.csv_settings)
 
     @property
-    def _data_hash_values(self) -> t.List[str]:
-        data = super()._data_hash_values
+    def _data_hash_values_no_sql(self) -> t.List[str]:
+        data = super()._data_hash_values_no_sql
         for column_name, column_hash in self.column_hashes.items():
             data.append(column_name)
             data.append(column_hash)
@@ -1847,8 +1917,8 @@ class PythonModel(_Model):
         return None
 
     @property
-    def _data_hash_values(self) -> t.List[str]:
-        data = super()._data_hash_values
+    def _data_hash_values_no_sql(self) -> t.List[str]:
+        data = super()._data_hash_values_no_sql
         data.append(self.entrypoint)
         return data
 
@@ -2227,6 +2297,7 @@ Learn more at https://sqlmesh.readthedocs.io/en/stable/concepts/models/overview
         variables=variables,
         inline_audits=inline_audits,
         blueprint_variables=blueprint_variables,
+        use_original_sql=True,
         **meta_fields,
     )
 
@@ -2449,6 +2520,7 @@ def _create_model(
     signal_definitions: t.Optional[SignalRegistry] = None,
     variables: t.Optional[t.Dict[str, t.Any]] = None,
     blueprint_variables: t.Optional[t.Dict[str, t.Any]] = None,
+    use_original_sql: bool = False,
     **kwargs: t.Any,
 ) -> Model:
     validate_extra_and_required_fields(
@@ -2482,34 +2554,26 @@ def _create_model(
 
     statements: t.List[t.Union[exp.Expression, t.Tuple[exp.Expression, bool]]] = []
 
-    # Merge default pre_statements with model-specific pre_statements
-    if "pre_statements" in defaults:
-        kwargs["pre_statements"] = [
-            exp.maybe_parse(stmt, dialect=dialect) for stmt in defaults["pre_statements"]
-        ] + kwargs.get("pre_statements", [])
-
-    # Merge default post_statements with model-specific post_statements
-    if "post_statements" in defaults:
-        kwargs["post_statements"] = [
-            exp.maybe_parse(stmt, dialect=dialect) for stmt in defaults["post_statements"]
-        ] + kwargs.get("post_statements", [])
-
-    # Merge default on_virtual_update with model-specific on_virtual_update
-    if "on_virtual_update" in defaults:
-        kwargs["on_virtual_update"] = [
-            exp.maybe_parse(stmt, dialect=dialect) for stmt in defaults["on_virtual_update"]
-        ] + kwargs.get("on_virtual_update", [])
-
-    if "pre_statements" in kwargs:
-        statements.extend(kwargs["pre_statements"])
     if "query" in kwargs:
         statements.append(kwargs["query"])
-    if "post_statements" in kwargs:
-        statements.extend(kwargs["post_statements"])
+        kwargs["query"] = ParsableSql.from_parsed_expression(
+            kwargs["query"], dialect, use_meta_sql=use_original_sql
+        )
 
-    # Macros extracted from these statements need to be treated as metadata only
-    if "on_virtual_update" in kwargs:
-        statements.extend((stmt, True) for stmt in kwargs["on_virtual_update"])
+    # Merge default statements with model-specific statements
+    for statement_field in ["pre_statements", "post_statements", "on_virtual_update"]:
+        if statement_field in defaults:
+            kwargs[statement_field] = [
+                exp.maybe_parse(stmt, dialect=dialect) for stmt in defaults[statement_field]
+            ] + kwargs.get(statement_field, [])
+        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])
+            kwargs[statement_field] = [
+                ParsableSql.from_parsed_expression(stmt, dialect, use_meta_sql=use_original_sql)
+                for stmt in kwargs[statement_field]
+            ]
 
     # This is done to allow variables like @gateway to be used in these properties
     # since rendering shifted from load time to run time.

{sqlmesh-0.212.1.dev3 → sqlmesh-0.212.1.dev4}/sqlmesh/core/node.py

@@ -307,16 +307,6 @@ class _Node(PydanticModel):
         """The maximal number of batches that can run concurrently for a backfill."""
         return None
 
-    @property
-    def data_hash(self) -> str:
-        """
-        Computes the data hash for the node.
-
-        Returns:
-            The data hash for the node.
-        """
-        raise NotImplementedError
-
     @property
     def interval_unit(self) -> IntervalUnit:
         """Returns the interval unit using which data intervals are computed for this node."""
@@ -332,6 +322,16 @@ class _Node(PydanticModel):
     def fqn(self) -> str:
         return self.name
 
+    @property
+    def data_hash(self) -> str:
+        """
+        Computes the data hash for the node.
+
+        Returns:
+            The data hash for the node.
+        """
+        raise NotImplementedError
+
     @property
     def metadata_hash(self) -> str:
         """
@@ -342,6 +342,30 @@ class _Node(PydanticModel):
         """
         raise NotImplementedError
 
+    def is_metadata_only_change(self, previous: _Node) -> bool:
+        """Determines if this node is a metadata only change in relation to the `previous` node.
+
+        Args:
+            previous: The previous node to compare against.
+
+        Returns:
+            True if this node is a metadata only change, False otherwise.
+        """
+        return self.data_hash == previous.data_hash and self.metadata_hash != previous.metadata_hash
+
+    def is_data_change(self, previous: _Node) -> bool:
+        """Determines if this node is a data change in relation to the `previous` node.
+
+        Args:
+            previous: The previous node to compare against.
+
+        Returns:
+            True if this node is a data change, False otherwise.
+        """
+        return (
+            self.data_hash != previous.data_hash or self.metadata_hash != previous.metadata_hash
+        ) and not self.is_metadata_only_change(previous)
+
     def croniter(self, value: TimeLike) -> CroniterCache:
         if self._croniter is None:
             self._croniter = CroniterCache(self.cron, value, tz=self.cron_tz)