Fix: Make the missing schema warning less noisy (#1025)

Author: izeigerman

sqlmesh/core/model/definition.py

@@ -462,13 +462,14 @@ def update_schema(self, schema: MappingSchema) -> None:
             else:
                 # Reset the entire mapping if at least one upstream dependency is missing from the mapping
                 # to prevent partial mappings from being used.
-                logger.warning(
-                    "Missing schema for model '%s' referenced in model '%s'. Run `sqlmesh create_external_models` "
-                    "and / or make sure that the model '%s' can be rendered at parse time",
-                    dep,
-                    self.name,
-                    dep,
-                )
+                if self.contains_star_projection:
+                    logger.warning(
+                        "Missing schema for model '%s' referenced in model '%s'. Run `sqlmesh create_external_models` "
+                        "and / or make sure that the model '%s' can be rendered at parse time",
+                        dep,
+                        self.name,
+                        dep,
+                    )
                 self.mapping_schema.clear()
                 return
 
@@ -481,6 +482,12 @@ def depends_on(self) -> t.Set[str]:
         """
         return self.depends_on_ or set()
 
+    @property
+    def contains_star_projection(self) -> t.Optional[bool]:
+        """Returns True if the model contains a star projection, False if it does not, and None if this
+        cannot be determined at parse time."""
+        return False
+
     @property
     def columns_to_types(self) -> t.Optional[t.Dict[str, exp.DataType]]:
         """Returns the mapping of column names to types of this model."""
@@ -756,21 +763,22 @@ def depends_on(self) -> t.Set[str]:
             self._depends_on -= {self.name}
         return self._depends_on
 
+    @property
+    def contains_star_projection(self) -> t.Optional[bool]:
+        columns_to_types = self._extract_columns_to_types()
+        if columns_to_types is None:
+            return None
+        return "*" in columns_to_types
+
     @property
     def columns_to_types(self) -> t.Optional[t.Dict[str, exp.DataType]]:
         if self.columns_to_types_ is not None:
             return self.columns_to_types_
 
-        if self._columns_to_types is None:
-            query = self._query_renderer.render()
-            if query is None:
-                return None
-            self._columns_to_types = d.extract_columns_to_types(query)
-
-        if "*" in self._columns_to_types:
+        columns_to_types = self._extract_columns_to_types()
+        if columns_to_types and "*" in columns_to_types:
             return None
-
-        return self._columns_to_types
+        return columns_to_types
 
     @property
     def column_descriptions(self) -> t.Dict[str, str]:
@@ -873,6 +881,13 @@ def _query_renderer(self) -> QueryRenderer:
             )
         return self.__query_renderer
 
+    def _extract_columns_to_types(self) -> t.Optional[t.Dict[str, exp.DataType]]:
+        if self._columns_to_types is None:
+            query = self._query_renderer.render()
+            if query is not None:
+                self._columns_to_types = d.extract_columns_to_types(query)
+        return self._columns_to_types
+
     def __repr__(self) -> str:
         return f"Model<name: {self.name}, query: {str(self.query)[0:30]}>"
 

tests/core/test_model.py

@@ -25,6 +25,7 @@
     model,
 )
 from sqlmesh.core.model.common import parse_expression
+from sqlmesh.core.renderer import QueryRenderer
 from sqlmesh.utils.date import to_datetime, to_timestamp
 from sqlmesh.utils.errors import ConfigError
 from sqlmesh.utils.metaprogramming import Executable
@@ -1443,6 +1444,8 @@ def test_check_schema_mapping_when_rendering_at_runtime(assert_exp_eq):
 
     # Simulate a query that cannot be rendered at parse time.
     with patch.object(SqlModel, "render_query", return_value=None) as render_query_mock:
+        assert not model.columns_to_types
+
         schema = MappingSchema(normalize=False)
         schema.add_table("table_b", {"b": exp.DataType.build("int")})
         model.update_schema(schema)
@@ -1456,3 +1459,33 @@ def test_check_schema_mapping_when_rendering_at_runtime(assert_exp_eq):
     assert_exp_eq(
         model.render_query(), """SELECT * FROM "table_a" AS "table_a", "table_b" AS "table_b" """
     )
+
+
+def test_contains_star_projection():
+    expression_with_star = d.parse(
+        """
+        MODEL (name db.table);
+        SELECT * FROM table_a
+        """
+    )
+
+    model = load_model(expression_with_star)
+    assert model.contains_star_projection
+    assert model.columns_to_types is None
+
+    # Simulate a query that cannot be rendered at parse time.
+    with patch.object(QueryRenderer, "render", return_value=None) as render_query_mock:
+        model._columns_to_types = None
+        assert model.contains_star_projection is None
+        assert model.columns_to_types is None
+
+    expression_without_star = d.parse(
+        """
+        MODEL (name db.table);
+        SELECT a FROM table_a
+        """
+    )
+
+    model = load_model(expression_without_star)
+    assert model.contains_star_projection is False
+    assert "a" in model.columns_to_types