Fix: treat all instances of macro variables as case-insensitive

Author: georgesittas

sqlmesh/core/macros.py

@@ -128,6 +128,23 @@ def _macro_str_replace(text: str) -> str:
     return f"self.template({text}, locals())"
 
 
+class CaseInsensitiveMapping(dict):
+    def __init__(self, data: t.Dict[str, t.Any]) -> None:
+        super().__init__(data)
+
+        self._lower = {k.lower(): v for k, v in data.items()}
+
+    def __getitem__(self, key: str) -> t.Any:
+        if key in self:
+            return super().__getitem__(key)
+        return self._lower[key.lower()]
+
+    def get(self, key: str, default: t.Any = None) -> t.Any:
+        if key in self:
+            return super().get(key, default)
+        return self._lower.get(key.lower(), default)
+
+
 class MacroDialect(Python):
     class Generator(Python.Generator):
         TRANSFORMS = {
@@ -313,11 +330,11 @@ def template(self, text: t.Any, local_variables: t.Dict[str, t.Any]) -> str:
         """
         # 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 = {
+        base_mapping = {
             k: convert_sql(v, self.dialect)
             for k, v in chain(self.variables.items(), self.locals.items(), local_variables.items())
         }
-        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):

tests/core/test_macros.py

@@ -1113,6 +1113,7 @@ def test_macro_with_spaces():
     for sql, expected in (
         ("@x", '"a b"'),
         ("@{x}", '"a b"'),
+        ("@{X}", '"a b"'),
         ("a_@x", '"a_a b"'),
         ("a.@x", 'a."a b"'),
         ("@y", "'a b'"),
@@ -1121,6 +1122,7 @@ def test_macro_with_spaces():
         ("a.@{y}", 'a."a b"'),
         ("@z", 'a."b c"'),
         ("d.@z", 'd.a."b c"'),
+        ("@'test_@{X}_suffix'", "'test_a b_suffix'"),
     ):
         assert evaluator.transform(parse_one(sql)).sql() == expected