sqlmesh 0.198.1.dev6__tar.gz → 0.198.1.dev7__tar.gz

{sqlmesh-0.198.1.dev6 → sqlmesh-0.198.1.dev7}/PKG-INFO

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

{sqlmesh-0.198.1.dev6 → sqlmesh-0.198.1.dev7}/sqlmesh/_version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.198.1.dev6'
-__version_tuple__ = version_tuple = (0, 198, 1, 'dev6')
+__version__ = version = '0.198.1.dev7'
+__version_tuple__ = version_tuple = (0, 198, 1, 'dev7')

{sqlmesh-0.198.1.dev6 → sqlmesh-0.198.1.dev7}/sqlmesh/core/dialect.py

@@ -1388,17 +1388,27 @@ def is_meta_expression(v: t.Any) -> bool:
     return isinstance(v, (Audit, Metric, Model))
 
 
-def replace_merge_table_aliases(expression: exp.Expression) -> exp.Expression:
+def replace_merge_table_aliases(
+    expression: exp.Expression, dialect: t.Optional[str] = None
+) -> exp.Expression:
     """
     Resolves references from the "source" and "target" tables (or their DBT equivalents)
     with the corresponding SQLMesh merge aliases (MERGE_SOURCE_ALIAS and MERGE_TARGET_ALIAS)
     """
     from sqlmesh.core.engine_adapter.base import MERGE_SOURCE_ALIAS, MERGE_TARGET_ALIAS
 
+    normalized_merge_source_alias = quote_identifiers(
+        normalize_identifiers(exp.to_identifier(MERGE_SOURCE_ALIAS), dialect), dialect=dialect
+    )
+
+    normalized_merge_target_alias = quote_identifiers(
+        normalize_identifiers(exp.to_identifier(MERGE_TARGET_ALIAS), dialect), dialect=dialect
+    )
+
     if isinstance(expression, exp.Column) and (first_part := expression.parts[0]):
         if first_part.this.lower() in ("target", "dbt_internal_dest", "__merge_target__"):
-            first_part.replace(exp.to_identifier(MERGE_TARGET_ALIAS))
+            first_part.replace(normalized_merge_target_alias)
         elif first_part.this.lower() in ("source", "dbt_internal_source", "__merge_source__"):
-            first_part.replace(exp.to_identifier(MERGE_SOURCE_ALIAS))
+            first_part.replace(normalized_merge_source_alias)
 
     return expression

{sqlmesh-0.198.1.dev6 → sqlmesh-0.198.1.dev7}/sqlmesh/core/model/definition.py

@@ -653,7 +653,7 @@ class _Model(ModelMeta, frozen=True):
         )
         if len(rendered_exprs) != 1:
             raise SQLMeshError(f"Expected one expression but got {len(rendered_exprs)}")
-        return rendered_exprs[0].transform(d.replace_merge_table_aliases)
+        return rendered_exprs[0].transform(d.replace_merge_table_aliases, dialect=self.dialect)
 
     def _render_properties(
         self, properties: t.Dict[str, exp.Expression] | SessionProperties, **render_kwargs: t.Any

{sqlmesh-0.198.1.dev6 → sqlmesh-0.198.1.dev7}/sqlmesh/core/model/kind.py

@@ -34,6 +34,7 @@ from sqlmesh.utils.pydantic import (
     get_dialect,
     validate_string,
     positive_int_validator,
+    validate_expression,
 )
 
 
@@ -467,15 +468,20 @@ class IncrementalByUniqueKeyKind(_IncrementalBy):
             return v
         if isinstance(v, list):
             v = " ".join(v)
+
+        dialect = get_dialect(info.data)
+
         if isinstance(v, str):
             # Whens wrap the WHEN clauses, but the parentheses aren't parsed by sqlglot
             v = v.strip()
             if v.startswith("("):
                 v = v[1:-1]
 
-            return t.cast(exp.Whens, d.parse_one(v, into=exp.Whens, dialect=get_dialect(info.data)))
+            v = t.cast(exp.Whens, d.parse_one(v, into=exp.Whens, dialect=dialect))
+        else:
+            v = t.cast(exp.Whens, v.transform(d.replace_merge_table_aliases, dialect=dialect))
 
-        return t.cast(exp.Whens, v.transform(d.replace_merge_table_aliases))
+        return validate_expression(v, dialect=dialect)
 
     @field_validator("merge_filter", mode="before")
     def _merge_filter_validator(
@@ -485,11 +491,16 @@ class IncrementalByUniqueKeyKind(_IncrementalBy):
     ) -> t.Optional[exp.Expression]:
         if v is None:
             return v
+
+        dialect = get_dialect(info.data)
+
         if isinstance(v, str):
             v = v.strip()
-            return d.parse_one(v, dialect=get_dialect(info.data))
+            v = d.parse_one(v, dialect=dialect)
+        else:
+            v = v.transform(d.replace_merge_table_aliases, dialect=dialect)
 
-        return v.transform(d.replace_merge_table_aliases)
+        return validate_expression(v, dialect=dialect)
 
     @property
     def data_hash_values(self) -> t.List[t.Optional[str]]:

sqlmesh-0.198.1.dev7/sqlmesh/migrations/v0084_normalize_quote_when_matched_and_merge_filter.py

@@ -0,0 +1,9 @@
+"""
+Normalize and quote the when_matched and merge_filter properties of IncrementalByUniqueKeyKind
+to match how other properties (such as time_column and partitioned_by) are handled and to
+prevent un-normalized identifiers being quoted at the EngineAdapter level
+"""
+
+
+def migrate(state_sync, **kwargs):  # type: ignore
+    pass

{sqlmesh-0.198.1.dev6 → sqlmesh-0.198.1.dev7}/sqlmesh/utils/pydantic.py

@@ -16,6 +16,8 @@ from sqlmesh.core import dialect as d
 from sqlmesh.utils import str_to_bool
 
 if t.TYPE_CHECKING:
+    from sqlglot._typing import E
+
     Model = t.TypeVar("Model", bound="PydanticModel")
 
 
@@ -193,6 +195,12 @@ def validate_string(v: t.Any) -> str:
     return str(v)
 
 
+def validate_expression(expression: E, dialect: str) -> E:
+    # this normalizes and quotes identifiers in the given expression according the specified dialect
+    # it also sets expression.meta["dialect"] so that when we serialize for state, the expression is serialized in the correct dialect
+    return _get_field(expression, {"dialect": dialect})  # type: ignore
+
+
 def bool_validator(v: t.Any) -> bool:
     if isinstance(v, exp.Boolean):
         return v.this

{sqlmesh-0.198.1.dev6 → sqlmesh-0.198.1.dev7}/sqlmesh.egg-info/PKG-INFO

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

{sqlmesh-0.198.1.dev6 → sqlmesh-0.198.1.dev7}/sqlmesh.egg-info/SOURCES.txt

@@ -455,6 +455,7 @@ sqlmesh/migrations/v0080_add_batch_size_to_scd_type_2_models.py
 sqlmesh/migrations/v0081_update_partitioned_by.py
 sqlmesh/migrations/v0082_warn_if_incorrectly_duplicated_statements.py
 sqlmesh/migrations/v0083_use_sql_for_scd_time_data_type_data_hash.py
+sqlmesh/migrations/v0084_normalize_quote_when_matched_and_merge_filter.py
 sqlmesh/schedulers/__init__.py
 sqlmesh/utils/__init__.py
 sqlmesh/utils/aws.py

{sqlmesh-0.198.1.dev6 → sqlmesh-0.198.1.dev7}/tests/core/test_model.py

@@ -5366,13 +5366,13 @@ def test_when_matched():
     """
     )
 
-    expected_when_matched = "(WHEN MATCHED THEN UPDATE SET __MERGE_TARGET__.salary = COALESCE(__MERGE_SOURCE__.salary, __MERGE_TARGET__.salary))"
+    expected_when_matched = "(WHEN MATCHED THEN UPDATE SET `__merge_target__`.`salary` = COALESCE(`__merge_source__`.`salary`, `__merge_target__`.`salary`))"
 
     model = load_sql_based_model(expressions, dialect="hive")
-    assert model.kind.when_matched.sql() == expected_when_matched
+    assert model.kind.when_matched.sql(dialect="hive") == expected_when_matched
 
     model = SqlModel.parse_raw(model.json())
-    assert model.kind.when_matched.sql() == expected_when_matched
+    assert model.kind.when_matched.sql(dialect="hive") == expected_when_matched
 
     expressions = d.parse(
         """
@@ -5400,9 +5400,9 @@ def test_when_matched():
   kind INCREMENTAL_BY_UNIQUE_KEY (
     unique_key ("purchase_order_id"),
     when_matched (
-      WHEN MATCHED AND __MERGE_SOURCE__._operation = 1 THEN DELETE
-      WHEN MATCHED AND __MERGE_SOURCE__._operation <> 1 THEN UPDATE SET
-        __MERGE_TARGET__.purchase_order_id = 1
+      WHEN MATCHED AND "__merge_source__"."_operation" = 1 THEN DELETE
+      WHEN MATCHED AND "__merge_source__"."_operation" <> 1 THEN UPDATE SET
+        "__merge_target__"."purchase_order_id" = 1
     ),
     batch_concurrency 1,
     forward_only FALSE,
@@ -5453,7 +5453,7 @@ FROM @{macro_val}.upstream"""
   kind INCREMENTAL_BY_UNIQUE_KEY (
     unique_key ("purchase_order_id"),
     when_matched (
-      WHEN MATCHED AND __MERGE_SOURCE__.salary <> __MERGE_TARGET__.salary THEN UPDATE SET
+      WHEN MATCHED AND "__merge_source__"."salary" <> "__merge_target__"."salary" THEN UPDATE SET
         ARRAY('target.update_datetime = source.update_datetime', 'target.salary = source.salary')
     ),
     batch_concurrency 1,
@@ -5487,21 +5487,21 @@ def test_when_matched_multiple():
     )
 
     expected_when_matched = [
-        "WHEN MATCHED AND __MERGE_SOURCE__.x = 1 THEN UPDATE SET __MERGE_TARGET__.salary = COALESCE(__MERGE_SOURCE__.salary, __MERGE_TARGET__.salary)",
-        "WHEN MATCHED THEN UPDATE SET __MERGE_TARGET__.salary = COALESCE(__MERGE_SOURCE__.salary, __MERGE_TARGET__.salary)",
+        "WHEN MATCHED AND `__merge_source__`.`x` = 1 THEN UPDATE SET `__merge_target__`.`salary` = COALESCE(`__merge_source__`.`salary`, `__merge_target__`.`salary`)",
+        "WHEN MATCHED THEN UPDATE SET `__merge_target__`.`salary` = COALESCE(`__merge_source__`.`salary`, `__merge_target__`.`salary`)",
     ]
 
     model = load_sql_based_model(expressions, dialect="hive", variables={"schema": "db"})
     whens = model.kind.when_matched
     assert len(whens.expressions) == 2
-    assert whens.expressions[0].sql() == expected_when_matched[0]
-    assert whens.expressions[1].sql() == expected_when_matched[1]
+    assert whens.expressions[0].sql(dialect="hive") == expected_when_matched[0]
+    assert whens.expressions[1].sql(dialect="hive") == expected_when_matched[1]
 
     model = SqlModel.parse_raw(model.json())
     whens = model.kind.when_matched
     assert len(whens.expressions) == 2
-    assert whens.expressions[0].sql() == expected_when_matched[0]
-    assert whens.expressions[1].sql() == expected_when_matched[1]
+    assert whens.expressions[0].sql(dialect="hive") == expected_when_matched[0]
+    assert whens.expressions[1].sql(dialect="hive") == expected_when_matched[1]
 
 
 def test_when_matched_merge_filter_multi_part_columns():
@@ -5529,28 +5529,86 @@ def test_when_matched_merge_filter_multi_part_columns():
     )
 
     expected_when_matched = [
-        "WHEN MATCHED AND __MERGE_SOURCE__.record.nested_record.field = 1 THEN UPDATE SET __MERGE_TARGET__.repeated_record.sub_repeated_record.sub_field = COALESCE(__MERGE_SOURCE__.repeated_record.sub_repeated_record.sub_field, __MERGE_TARGET__.repeated_record.sub_repeated_record.sub_field)",
-        "WHEN MATCHED THEN UPDATE SET __MERGE_TARGET__.repeated_record.sub_repeated_record.sub_field = COALESCE(__MERGE_SOURCE__.repeated_record.sub_repeated_record.sub_field, __MERGE_TARGET__.repeated_record.sub_repeated_record.sub_field)",
+        "WHEN MATCHED AND `__merge_source__`.`record`.`nested_record`.`field` = 1 THEN UPDATE SET `__merge_target__`.`repeated_record`.`sub_repeated_record`.`sub_field` = COALESCE(`__merge_source__`.`repeated_record`.`sub_repeated_record`.`sub_field`, `__merge_target__`.`repeated_record`.`sub_repeated_record`.`sub_field`)",
+        "WHEN MATCHED THEN UPDATE SET `__merge_target__`.`repeated_record`.`sub_repeated_record`.`sub_field` = COALESCE(`__merge_source__`.`repeated_record`.`sub_repeated_record`.`sub_field`, `__merge_target__`.`repeated_record`.`sub_repeated_record`.`sub_field`)",
     ]
 
     expected_merge_filter = (
-        "__MERGE_SOURCE__.record.nested_record.field < __MERGE_TARGET__.record.nested_record.field AND "
-        "__MERGE_TARGET__.repeated_record.sub_repeated_record.sub_field > __MERGE_SOURCE__.repeated_record.sub_repeated_record.sub_field"
+        "`__merge_source__`.`record`.`nested_record`.`field` < `__merge_target__`.`record`.`nested_record`.`field` AND "
+        "`__merge_target__`.`repeated_record`.`sub_repeated_record`.`sub_field` > `__merge_source__`.`repeated_record`.`sub_repeated_record`.`sub_field`"
     )
 
     model = load_sql_based_model(expressions, dialect="bigquery", variables={"schema": "db"})
     whens = model.kind.when_matched
     assert len(whens.expressions) == 2
-    assert whens.expressions[0].sql() == expected_when_matched[0]
-    assert whens.expressions[1].sql() == expected_when_matched[1]
-    assert model.merge_filter.sql() == expected_merge_filter
+    assert whens.expressions[0].sql(dialect="bigquery") == expected_when_matched[0]
+    assert whens.expressions[1].sql(dialect="bigquery") == expected_when_matched[1]
+    assert model.merge_filter.sql(dialect="bigquery") == expected_merge_filter
 
     model = SqlModel.parse_raw(model.json())
     whens = model.kind.when_matched
     assert len(whens.expressions) == 2
-    assert whens.expressions[0].sql() == expected_when_matched[0]
-    assert whens.expressions[1].sql() == expected_when_matched[1]
-    assert model.merge_filter.sql() == expected_merge_filter
+    assert whens.expressions[0].sql(dialect="bigquery") == expected_when_matched[0]
+    assert whens.expressions[1].sql(dialect="bigquery") == expected_when_matched[1]
+    assert model.merge_filter.sql(dialect="bigquery") == expected_merge_filter
+
+
+def test_when_matched_normalization() -> None:
+    # unquoted should be normalized and quoted
+    expressions = d.parse(
+        """
+        MODEL (
+          name test.employees,
+          kind INCREMENTAL_BY_UNIQUE_KEY (
+            unique_key name,
+            when_matched (
+                WHEN MATCHED THEN UPDATE SET
+                    target.key_a = source.key_a,
+                    target.key_b = source.key_b,            
+            )
+          )
+        );
+        SELECT 'name' AS name, 1 AS key_a, 2 AS key_b;
+    """
+    )
+    model = load_sql_based_model(expressions, dialect="snowflake")
+
+    assert isinstance(model.kind, IncrementalByUniqueKeyKind)
+    assert isinstance(model.kind.when_matched, exp.Whens)
+    first_expression = model.kind.when_matched.expressions[0]
+    assert isinstance(first_expression, exp.Expression)
+    assert (
+        first_expression.sql(dialect="snowflake")
+        == 'WHEN MATCHED THEN UPDATE SET "__MERGE_TARGET__"."KEY_A" = "__MERGE_SOURCE__"."KEY_A", "__MERGE_TARGET__"."KEY_B" = "__MERGE_SOURCE__"."KEY_B"'
+    )
+
+    # quoted should be preserved
+    expressions = d.parse(
+        """
+        MODEL (
+          name test.employees,
+          kind INCREMENTAL_BY_UNIQUE_KEY (
+            unique_key name,
+            when_matched (
+                WHEN MATCHED THEN UPDATE SET
+                    target."kEy_A" = source."kEy_A",
+                    target."kEY_b" = source.key_b,
+            )
+          )
+        );
+        SELECT 'name' AS name, 1 AS "kEy_A", 2 AS "kEY_b";
+    """
+    )
+    model = load_sql_based_model(expressions, dialect="snowflake")
+
+    assert isinstance(model.kind, IncrementalByUniqueKeyKind)
+    assert isinstance(model.kind.when_matched, exp.Whens)
+    first_expression = model.kind.when_matched.expressions[0]
+    assert isinstance(first_expression, exp.Expression)
+    assert (
+        first_expression.sql(dialect="snowflake")
+        == 'WHEN MATCHED THEN UPDATE SET "__MERGE_TARGET__"."kEy_A" = "__MERGE_SOURCE__"."kEy_A", "__MERGE_TARGET__"."kEY_b" = "__MERGE_SOURCE__"."KEY_B"'
+    )
 
 
 def test_default_catalog_sql(assert_exp_eq):
@@ -6492,11 +6550,11 @@ def test_unrendered_macros_python_model(mocker: MockerFixture) -> None:
         == "@IF(@gateway = 'dev', @'hdfs://@{catalog_name}/@{schema_name}/dev/@{table_name}', @'s3://prod/@{table_name}')"
     )
 
-    # Merge_filter will stay unrendered as well
+    # merge_filter will stay unrendered as well
     assert python_sql_model.unique_key[0] == exp.column("a", quoted=True)
     assert (
         python_sql_model.merge_filter.sql()
-        == "source.id > 0 AND target.updated_at < @end_ds AND source.updated_at > @start_ds"
+        == '"source"."id" > 0 AND "target"."updated_at" < @end_ds AND "source"."updated_at" > @start_ds'
     )
 
 
@@ -7583,7 +7641,7 @@ on_destructive_change 'ERROR'
         .sql()
         == """INCREMENTAL_BY_UNIQUE_KEY (
 unique_key ("a"),
-when_matched (WHEN MATCHED THEN UPDATE SET __MERGE_TARGET__.b = COALESCE(__MERGE_SOURCE__.b, __MERGE_TARGET__.b)),
+when_matched (WHEN MATCHED THEN UPDATE SET "__merge_target__"."b" = COALESCE("__merge_source__"."b", "__merge_target__"."b")),
 batch_concurrency 1,
 forward_only FALSE,
 disable_restatement FALSE,
@@ -7611,7 +7669,7 @@ on_destructive_change 'ERROR'
         .sql()
         == """INCREMENTAL_BY_UNIQUE_KEY (
 unique_key ("a"),
-when_matched (WHEN MATCHED AND __MERGE_SOURCE__.x = 1 THEN UPDATE SET __MERGE_TARGET__.b = COALESCE(__MERGE_SOURCE__.b, __MERGE_TARGET__.b) WHEN MATCHED THEN UPDATE SET __MERGE_TARGET__.b = COALESCE(__MERGE_SOURCE__.b, __MERGE_TARGET__.b)),
+when_matched (WHEN MATCHED AND "__merge_source__"."x" = 1 THEN UPDATE SET "__merge_target__"."b" = COALESCE("__merge_source__"."b", "__merge_target__"."b") WHEN MATCHED THEN UPDATE SET "__merge_target__"."b" = COALESCE("__merge_source__"."b", "__merge_target__"."b")),
 batch_concurrency 1,
 forward_only FALSE,
 disable_restatement FALSE,
@@ -7872,13 +7930,14 @@ def test_merge_filter():
     """
     )
 
-    expected_incremental_predicate = f"{MERGE_SOURCE_ALIAS}.salary > 0"
+    expected_incremental_predicate = f"`{MERGE_SOURCE_ALIAS.lower()}`.`salary` > 0"
 
     model = load_sql_based_model(expressions, dialect="hive")
-    assert model.kind.merge_filter.sql() == expected_incremental_predicate
+    assert model.kind.merge_filter.sql(dialect="hive") == expected_incremental_predicate
 
     model = SqlModel.parse_raw(model.json())
-    assert model.kind.merge_filter.sql() == expected_incremental_predicate
+    assert model.kind.merge_filter.sql(dialect="hive") == expected_incremental_predicate
+    assert model.dialect == "hive"
 
     expressions = d.parse(
         """
@@ -7894,7 +7953,7 @@ def test_merge_filter():
                 source.ds > (SELECT MAX(ds) FROM db.test) AND
                 source.ds > @start_ds AND
                 source._operation <> 1 AND
-                target.start_date > dateadd(day, -7, current_date)
+                target.start_date > date_add(current_date, interval 7 day)
             )
           )
         );
@@ -7906,26 +7965,27 @@ def test_merge_filter():
         """
     )
 
-    model = SqlModel.parse_raw(load_sql_based_model(expressions).json())
-    assert d.format_model_expressions(model.render_definition()) == (
+    model = SqlModel.parse_raw(load_sql_based_model(expressions, dialect="duckdb").json())
+    assert d.format_model_expressions(model.render_definition(), dialect=model.dialect) == (
         f"""MODEL (
   name db.test,
+  dialect duckdb,
   kind INCREMENTAL_BY_UNIQUE_KEY (
     unique_key ("purchase_order_id"),
     when_matched (
-      WHEN MATCHED AND {MERGE_SOURCE_ALIAS}._operation = 1 THEN DELETE
-      WHEN MATCHED AND {MERGE_SOURCE_ALIAS}._operation <> 1 THEN UPDATE SET
-        {MERGE_TARGET_ALIAS}.purchase_order_id = 1
+      WHEN MATCHED AND "{MERGE_SOURCE_ALIAS.lower()}"."_operation" = 1 THEN DELETE
+      WHEN MATCHED AND "{MERGE_SOURCE_ALIAS.lower()}"."_operation" <> 1 THEN UPDATE SET
+        "{MERGE_TARGET_ALIAS.lower()}"."purchase_order_id" = 1
     ),
     merge_filter (
-      {MERGE_SOURCE_ALIAS}.ds > (
+      "{MERGE_SOURCE_ALIAS.lower()}"."ds" > (
         SELECT
-          MAX(ds)
-        FROM db.test
+          MAX("ds")
+        FROM "db"."test"
       )
-      AND {MERGE_SOURCE_ALIAS}.ds > @start_ds
-      AND {MERGE_SOURCE_ALIAS}._operation <> 1
-      AND {MERGE_TARGET_ALIAS}.start_date > DATEADD(day, -7, CURRENT_DATE)
+      AND "{MERGE_SOURCE_ALIAS.lower()}"."ds" > @start_ds
+      AND "{MERGE_SOURCE_ALIAS.lower()}"."_operation" <> 1
+      AND "{MERGE_TARGET_ALIAS.lower()}"."start_date" > CURRENT_DATE + INTERVAL '7' DAY
     ),
     batch_concurrency 1,
     forward_only FALSE,
@@ -7942,10 +8002,46 @@ FROM db.upstream"""
 
     rendered_merge_filters = model.render_merge_filter(start="2023-01-01", end="2023-01-02")
     assert (
-        rendered_merge_filters.sql()
-        == "(__MERGE_SOURCE__.ds > (SELECT MAX(ds) FROM db.test) AND __MERGE_SOURCE__.ds > '2023-01-01' AND __MERGE_SOURCE__._operation <> 1 AND __MERGE_TARGET__.start_date > DATEADD(day, -7, CURRENT_DATE))"
+        rendered_merge_filters.sql(dialect="hive")
+        == "(`__merge_source__`.`ds` > (SELECT MAX(`ds`) FROM `db`.`test`) AND `__merge_source__`.`ds` > '2023-01-01' AND `__merge_source__`.`_operation` <> 1 AND `__merge_target__`.`start_date` > CURRENT_DATE + INTERVAL '7' DAY)"
+    )
+
+
+def test_merge_filter_normalization():
+    # unquoted gets normalized and quoted
+    expressions = d.parse(
+        """
+        MODEL (
+          name db.employees,
+          kind INCREMENTAL_BY_UNIQUE_KEY (
+            unique_key name,
+            merge_filter source.salary > 0
+          )
+        );
+        SELECT 'name' AS name, 1 AS salary;
+    """
     )
 
+    model = load_sql_based_model(expressions, dialect="snowflake")
+    assert model.merge_filter.sql(dialect="snowflake") == '"__MERGE_SOURCE__"."SALARY" > 0'
+
+    # quoted gets preserved
+    expressions = d.parse(
+        """
+        MODEL (
+          name db.employees,
+          kind INCREMENTAL_BY_UNIQUE_KEY (
+            unique_key name,
+            merge_filter source."SaLArY" > 0
+          )
+        );
+        SELECT 'name' AS name, 1 AS "SaLArY";
+    """
+    )
+
+    model = load_sql_based_model(expressions, dialect="snowflake")
+    assert model.merge_filter.sql(dialect="snowflake") == '"__MERGE_SOURCE__"."SaLArY" > 0'
+
 
 def test_merge_filter_macro():
     @macro()
@@ -7969,19 +8065,20 @@ def test_merge_filter_macro():
     """
     )
 
-    unrendered_merge_filter = (
-        f"@predicate(update_datetime) AND {MERGE_TARGET_ALIAS}.update_datetime > @start_dt"
+    unrendered_merge_filter = f"""@predicate("UPDATE_DATETIME") AND "{MERGE_TARGET_ALIAS}"."UPDATE_DATETIME" > @start_dt"""
+    expected_merge_filter = (
+        f"""\"{MERGE_SOURCE_ALIAS}"."UPDATE_DATETIME" > DATEADD(DAY, -7, "{MERGE_TARGET_ALIAS}"."UPDATE_DATETIME") """
+        f"""AND "{MERGE_TARGET_ALIAS}"."UPDATE_DATETIME" > CAST('2023-01-01 15:00:00+00:00' AS TIMESTAMPTZ)"""
     )
-    expected_merge_filter = f"{MERGE_SOURCE_ALIAS}.UPDATE_DATETIME > DATE_ADD({MERGE_TARGET_ALIAS}.UPDATE_DATETIME, -7, 'DAY') AND {MERGE_TARGET_ALIAS}.UPDATE_DATETIME > CAST('2023-01-01 15:00:00+00:00' AS TIMESTAMPTZ)"
 
     model = load_sql_based_model(expressions, dialect="snowflake")
-    assert model.kind.merge_filter.sql() == unrendered_merge_filter
+    assert model.kind.merge_filter.sql(dialect=model.dialect) == unrendered_merge_filter
 
     model = SqlModel.parse_raw(model.json())
-    assert model.kind.merge_filter.sql() == unrendered_merge_filter
+    assert model.kind.merge_filter.sql(dialect=model.dialect) == unrendered_merge_filter
 
     rendered_merge_filters = model.render_merge_filter(start="2023-01-01 15:00:00")
-    assert rendered_merge_filters.sql() == expected_merge_filter
+    assert rendered_merge_filters.sql(dialect=model.dialect) == expected_merge_filter
 
 
 @pytest.mark.parametrize(

{sqlmesh-0.198.1.dev6 → sqlmesh-0.198.1.dev7}/tests/core/test_snapshot_evaluator.py

@@ -2211,13 +2211,19 @@ def test_create_incremental_by_unique_key_updated_at_exp(adapter_mock, make_snap
                     source=False,
                     then=exp.Update(
                         expressions=[
-                            exp.column("name", MERGE_TARGET_ALIAS).eq(
-                                exp.column("name", MERGE_SOURCE_ALIAS)
+                            exp.column("name", MERGE_TARGET_ALIAS.lower(), quoted=True).eq(
+                                exp.column("name", MERGE_SOURCE_ALIAS.lower(), quoted=True)
                             ),
-                            exp.column("updated_at", MERGE_TARGET_ALIAS).eq(
+                            exp.column("updated_at", MERGE_TARGET_ALIAS.lower(), quoted=True).eq(
                                 exp.Coalesce(
-                                    this=exp.column("updated_at", MERGE_SOURCE_ALIAS),
-                                    expressions=[exp.column("updated_at", MERGE_TARGET_ALIAS)],
+                                    this=exp.column(
+                                        "updated_at", MERGE_SOURCE_ALIAS.lower(), quoted=True
+                                    ),
+                                    expressions=[
+                                        exp.column(
+                                            "updated_at", MERGE_TARGET_ALIAS.lower(), quoted=True
+                                        )
+                                    ],
                                 )
                             ),
                         ],
@@ -2273,16 +2279,24 @@ def test_create_incremental_by_unique_key_multiple_updated_at_exp(adapter_mock,
             expressions=[
                 exp.When(
                     matched=True,
-                    condition=exp.column("id", MERGE_SOURCE_ALIAS).eq(exp.Literal.number(1)),
+                    condition=exp.column("id", MERGE_SOURCE_ALIAS.lower(), quoted=True).eq(
+                        exp.Literal.number(1)
+                    ),
                     then=exp.Update(
                         expressions=[
-                            exp.column("name", MERGE_TARGET_ALIAS).eq(
-                                exp.column("name", MERGE_SOURCE_ALIAS)
+                            exp.column("name", MERGE_TARGET_ALIAS.lower(), quoted=True).eq(
+                                exp.column("name", MERGE_SOURCE_ALIAS.lower(), quoted=True)
                             ),
-                            exp.column("updated_at", MERGE_TARGET_ALIAS).eq(
+                            exp.column("updated_at", MERGE_TARGET_ALIAS.lower(), quoted=True).eq(
                                 exp.Coalesce(
-                                    this=exp.column("updated_at", MERGE_SOURCE_ALIAS),
-                                    expressions=[exp.column("updated_at", MERGE_TARGET_ALIAS)],
+                                    this=exp.column(
+                                        "updated_at", MERGE_SOURCE_ALIAS.lower(), quoted=True
+                                    ),
+                                    expressions=[
+                                        exp.column(
+                                            "updated_at", MERGE_TARGET_ALIAS.lower(), quoted=True
+                                        )
+                                    ],
                                 )
                             ),
                         ],
@@ -2293,13 +2307,19 @@ def test_create_incremental_by_unique_key_multiple_updated_at_exp(adapter_mock,
                     source=False,
                     then=exp.Update(
                         expressions=[
-                            exp.column("name", MERGE_TARGET_ALIAS).eq(
-                                exp.column("name", MERGE_SOURCE_ALIAS)
+                            exp.column("name", MERGE_TARGET_ALIAS.lower(), quoted=True).eq(
+                                exp.column("name", MERGE_SOURCE_ALIAS.lower(), quoted=True)
                             ),
-                            exp.column("updated_at", MERGE_TARGET_ALIAS).eq(
+                            exp.column("updated_at", MERGE_TARGET_ALIAS.lower(), quoted=True).eq(
                                 exp.Coalesce(
-                                    this=exp.column("updated_at", MERGE_SOURCE_ALIAS),
-                                    expressions=[exp.column("updated_at", MERGE_TARGET_ALIAS)],
+                                    this=exp.column(
+                                        "updated_at", MERGE_SOURCE_ALIAS.lower(), quoted=True
+                                    ),
+                                    expressions=[
+                                        exp.column(
+                                            "updated_at", MERGE_TARGET_ALIAS.lower(), quoted=True
+                                        )
+                                    ],
                                 )
                             ),
                         ],
@@ -2384,16 +2404,16 @@ def test_create_incremental_by_unique_key_merge_filter(adapter_mock, make_snapsh
     assert model.merge_filter == exp.And(
         this=exp.And(
             this=exp.GT(
-                this=exp.column("id", MERGE_SOURCE_ALIAS),
+                this=exp.column("id", MERGE_SOURCE_ALIAS.lower(), quoted=True),
                 expression=exp.Literal(this="0", is_string=False),
             ),
             expression=exp.LT(
-                this=exp.column("updated_at", MERGE_TARGET_ALIAS),
+                this=exp.column("updated_at", MERGE_TARGET_ALIAS.lower(), quoted=True),
                 expression=d.MacroVar(this="end_ds"),
             ),
         ),
         expression=exp.GT(
-            this=exp.column("updated_at", MERGE_SOURCE_ALIAS),
+            this=exp.column("updated_at", MERGE_SOURCE_ALIAS.lower(), quoted=True),
             expression=d.MacroVar(this="start_ds"),
         ),
     )
@@ -2425,10 +2445,16 @@ def test_create_incremental_by_unique_key_merge_filter(adapter_mock, make_snapsh
                     matched=True,
                     then=exp.Update(
                         expressions=[
-                            exp.column("updated_at", MERGE_TARGET_ALIAS).eq(
+                            exp.column("updated_at", MERGE_TARGET_ALIAS.lower(), quoted=True).eq(
                                 exp.Coalesce(
-                                    this=exp.column("updated_at", MERGE_SOURCE_ALIAS),
-                                    expressions=[exp.column("updated_at", MERGE_TARGET_ALIAS)],
+                                    this=exp.column(
+                                        "updated_at", MERGE_SOURCE_ALIAS.lower(), quoted=True
+                                    ),
+                                    expressions=[
+                                        exp.column(
+                                            "updated_at", MERGE_TARGET_ALIAS.lower(), quoted=True
+                                        )
+                                    ],
                                 )
                             ),
                         ],
@@ -2439,16 +2465,16 @@ def test_create_incremental_by_unique_key_merge_filter(adapter_mock, make_snapsh
         merge_filter=exp.And(
             this=exp.And(
                 this=exp.GT(
-                    this=exp.column("id", MERGE_SOURCE_ALIAS),
+                    this=exp.column("id", MERGE_SOURCE_ALIAS.lower(), quoted=True),
                     expression=exp.Literal(this="0", is_string=False),
                 ),
                 expression=exp.LT(
-                    this=exp.column("updated_at", MERGE_TARGET_ALIAS),
+                    this=exp.column("updated_at", MERGE_TARGET_ALIAS.lower(), quoted=True),
                     expression=exp.Literal(this="2020-01-02", is_string=True),
                 ),
             ),
             expression=exp.GT(
-                this=exp.column("updated_at", MERGE_SOURCE_ALIAS),
+                this=exp.column("updated_at", MERGE_SOURCE_ALIAS.lower(), quoted=True),
                 expression=exp.Literal(this="2020-01-01", is_string=True),
             ),
         ),