fix(format): stop kind's own render policy from transpiling scalar siblings

Recursing _holds_expression into nested Pydantic models to correctly
classify TimeColumn (IncrementalByTimeRangeKind.time_column) as
warehouse SQL had the side effect of also matching ModelMeta.kind
itself, since some member of the ModelKind union holds an expression
field. That routed the entire kind (...) subtree through a
dialect-specific generator, so on tsql a scalar sibling like
forward_only TRUE was rewritten to (1 = 1) -- which reparses fine but
silently evaluates to False on reload via str_to_bool.

kind's own nested properties are already independently dialect-tagged
via the ModelKind expression node's own meta when _props_sql recurses
into them, so the outer kind property's policy should never route its
subtree through render_with_model_dialect. Stop _holds_expression at
_ModelKind subclasses to restore that.

Signed-off-by: mday-io <mdaytn@gmail.com>

Author: mday-io

sqlmesh/core/dialect.py

@@ -744,10 +744,24 @@ def _holds_expression(annotation: t.Any, _visited: t.Optional[t.FrozenSet[t.Any]
     nested Tuple[str, Dict[str, exp.Expr]] shape used by audits/signals, and nested
     Pydantic models that themselves wrap an expression field, such as `TimeColumn`
     (IncrementalByTimeRangeKind.time_column).
+
+    Stops at `_ModelKind` subclasses without recursing into their fields: a `kind`
+    property's own nested properties are independently dialect-tagged via the
+    `ModelKind` expression node's own meta when `_props_sql` recurses into them, so
+    treating the `kind` field itself as "holds an expression" -- true only because some
+    other member of the `ModelKind` union has an expression field, e.g.
+    `IncrementalByTimeRangeKind.time_column` -- would route its entire subtree,
+    including scalar sibling properties like `forward_only`, through a dialect-specific
+    generator and transpile them when they shouldn't be (tsql booleans becoming
+    `(1 = 1)`, which silently reparses as `False`).
     """
+    from sqlmesh.core.model.kind import _ModelKind
+
     if isinstance(annotation, type):
         if issubclass(annotation, exp.Expr):
             return True
+        if issubclass(annotation, _ModelKind):
+            return False
         visited = _visited or frozenset()
         if annotation in visited:
             return False

tests/core/test_dialect.py

@@ -516,6 +516,61 @@ def test_format_model_expressions_time_column_dialect():
     )
 
 
+def test_format_model_expressions_kind_scalar_sibling_dialect():
+    """A scalar sibling property of an expression-bearing property inside `kind` (e.g.
+    `forward_only` next to `time_column`) must stay dialect-agnostic even though the
+    render policy correctly marks `kind` as containing an expression-holding field
+    somewhere in the `ModelKind` union.
+
+    Regression: recursing into nested Pydantic models to fix `time_column` (see
+    `test_format_model_expressions_time_column_dialect`) made `_holds_expression` also
+    match on `kind` itself, since *some* member of the `ModelKind` union
+    (`IncrementalByTimeRangeKind.time_column`) holds an expression. That routed the
+    entire `kind (...)` subtree through a dialect-specific generator, so tsql's
+    boolean-literal preprocessing rewrote `forward_only TRUE` into `forward_only (1 = 1)`.
+    That reparses without error, but `str_to_bool` on `Paren(EQ(1, 1)).name` (`""`)
+    evaluates to `False`, so the value silently flips on reload.
+    """
+    formatted = format_model_expressions(
+        parse(
+            """
+            MODEL (
+              name a.b,
+              dialect tsql,
+              kind INCREMENTAL_BY_TIME_RANGE (
+                time_column [end],
+                forward_only true
+              )
+            );
+
+            SELECT 1 AS x, [end] FROM t
+            """,
+            default_dialect="tsql",
+        ),
+        dialect="tsql",
+    )
+
+    assert (
+        formatted
+        == """MODEL (
+  name a.b,
+  dialect tsql,
+  kind INCREMENTAL_BY_TIME_RANGE (
+    time_column [end],
+    forward_only TRUE
+  )
+);
+
+SELECT
+  1 AS x,
+  [end]
+FROM t"""
+    )
+
+    model = load_sql_based_model(parse(formatted, default_dialect="tsql"), dialect="tsql")
+    assert model.kind.forward_only is True
+
+
 def test_format_model_expressions_macro_property_comments_preserved_with_dialect():
     """Comments inside a macro header-property must survive formatting when the model
     has a `dialect` set.