PR feedback

Author: georgesittas

sqlmesh/core/model/definition.py

@@ -594,8 +594,7 @@ def _statement_renderer(self, expression: exp.Expression) -> ExpressionRenderer:
                 python_env=self.python_env,
                 only_execution_time=False,
                 default_catalog=self.default_catalog,
-                model_fqn=self.fqn,
-                raw_code=self._raw_code,
+                model=self,
             )
         return self._statement_renderer_cache[expression_key]
 
@@ -1306,10 +1305,6 @@ def _is_time_column_in_partitioned_by(self) -> bool:
     def violated_rules_for_query(self) -> t.Dict[type[Rule], t.Any]:
         return {}
 
-    @property
-    def _raw_code(self) -> t.Optional[str]:
-        return None
-
 
 class SqlModel(_Model):
     """The model definition which relies on a SQL query to fetch the data.
@@ -1578,15 +1573,14 @@ def _query_renderer(self) -> QueryRenderer:
             self.dialect,
             self.macro_definitions,
             schema=self.mapping_schema,
-            model_fqn=self.fqn,
             path=self._path,
             jinja_macro_registry=self.jinja_macros,
             python_env=self.python_env,
             only_execution_time=self.kind.only_execution_time,
             default_catalog=self.default_catalog,
             quote_identifiers=not no_quote_identifiers,
             optimize_query=self.optimize_query,
-            raw_code=self._raw_code,
+            model=self,
         )
 
     @property
@@ -1612,11 +1606,6 @@ def violated_rules_for_query(self) -> t.Dict[type[Rule], t.Any]:
         self.render_query()
         return self._query_renderer._violated_rules
 
-    @property
-    def _raw_code(self) -> t.Optional[str]:
-        query = self.query
-        return query.name if isinstance(query, d.JinjaQuery) else None
-
 
 class SeedModel(_Model):
     """The model definition which uses a pre-built static dataset to source the data from.

sqlmesh/core/renderer.py

@@ -31,6 +31,7 @@
     from sqlglot.dialects.dialect import DialectType
 
     from sqlmesh.core.linter.rule import Rule
+    from sqlmesh.core.model.definition import _Model
     from sqlmesh.core.snapshot import DeployabilityIndex, Snapshot
 
 
@@ -50,10 +51,9 @@ def __init__(
         schema: t.Optional[t.Dict[str, t.Any]] = None,
         default_catalog: t.Optional[str] = None,
         quote_identifiers: bool = True,
-        model_fqn: t.Optional[str] = None,
         normalize_identifiers: bool = True,
         optimize_query: t.Optional[bool] = True,
-        raw_code: t.Optional[str] = None,
+        model: t.Optional[_Model] = None,
     ):
         self._expression = expression
         self._dialect = dialect
@@ -67,9 +67,9 @@ def __init__(
         self._quote_identifiers = quote_identifiers
         self.update_schema({} if schema is None else schema)
         self._cache: t.List[t.Optional[exp.Expression]] = []
-        self._model_fqn = model_fqn
+        self._model_fqn = model.fqn if model else None
         self._optimize_query_flag = optimize_query is not False
-        self._raw_code = raw_code
+        self._model = model
 
     def update_schema(self, schema: t.Dict[str, t.Any]) -> None:
         self.schema = d.normalize_mapping_schema(schema, dialect=self._dialect)
@@ -206,7 +206,7 @@ def _resolve_table(table: str | exp.Table) -> str:
                     "default_catalog": self._default_catalog,
                     "runtime_stage": runtime_stage.value,
                     "resolve_table": _resolve_table,
-                    "raw_code": self._raw_code,
+                    "model_instance": self._model,
                 }
 
                 if this_model:

sqlmesh/dbt/builtin.py

@@ -16,6 +16,7 @@
 
 from sqlmesh.core.console import get_console
 from sqlmesh.core.engine_adapter import EngineAdapter
+from sqlmesh.core.model.definition import SqlModel
 from sqlmesh.core.snapshot.definition import DeployabilityIndex
 from sqlmesh.dbt.adapter import BaseAdapter, ParsetimeAdapter, RuntimeAdapter
 from sqlmesh.dbt.common import RAW_CODE_KEY
@@ -27,12 +28,6 @@
 from sqlmesh.utils.errors import ConfigError, MacroEvalError
 from sqlmesh.utils.jinja import JinjaMacroRegistry, MacroReference, MacroReturnVal
 
-if t.TYPE_CHECKING:
-    from typing import Protocol
-
-    class Model(Protocol):
-        def __getattr__(self, key: str) -> t.Any: ...
-
 
 logger = logging.getLogger(__name__)
 
@@ -485,8 +480,12 @@ def create_builtin_globals(
     )
 
     if (model := jinja_globals.pop("model", None)) is not None:
-        raw_code = jinja_globals.pop("raw_code", "")
-        builtin_globals["model"] = AttributeDict({**model, RAW_CODE_KEY: raw_code})
+        if isinstance(model_instance := jinja_globals.pop("model_instance", None), SqlModel):
+            builtin_globals["model"] = AttributeDict(
+                {**model, RAW_CODE_KEY: model_instance.query.name}
+            )
+        else:
+            builtin_globals["model"] = AttributeDict(model.copy())
 
     if engine_adapter is not None:
         builtin_globals["flags"] = Flags(which="run")

sqlmesh/migrations/v0095_warn_about_dbt_raw_sql_diff.py

@@ -25,12 +25,12 @@ def migrate(state_sync, **kwargs):  # type: ignore
         snapshots_table = f"{schema}.{snapshots_table}"
 
     warning = (
-        "SQLMesh now includes dbt's {{ config(...) }} blocks in the model's raw SQL when "
-        "processing dbt models. This change ensures that all model attributes referenced "
-        "in macros are properly tracked for fingerprinting. As a result, you may see diffs "
-        "for existing dbt models even though the actual SQL logic hasn't changed. This is "
-        "a one-time diff that will be resolved after applying a plan. Run 'sqlmesh diff prod' "
-        "to review any changes, then apply a plan if the diffs look expected."
+        "SQLMesh detected that it may not be able to fully migrate the state database. This should not impact "
+        "the migration process, but may result in unexpected changes being reported by the next `sqlmesh plan` "
+        "command. Please run `sqlmesh diff prod` after the migration has completed, before making any new "
+        "changes. If any unexpected changes are reported, consider running a forward-only plan to apply these "
+        "changes and avoid unnecessary backfills: sqlmesh plan prod --forward-only. "
+        "See https://sqlmesh.readthedocs.io/en/stable/concepts/plans/#forward-only-plans for more details.\n"
     )
 
     for (snapshot,) in engine_adapter.fetchall(