From 502d73649d268295c40e9e01666b6bdf9051593e Mon Sep 17 00:00:00 2001
From: Chris Eubank <108756251+christianeu-db@users.noreply.github.com>
Date: Fri, 18 Sep 2026 21:50:20 +0000
Subject: [PATCH 1/2] fix(databricks): match cascade-drop references
 case-insensitively

Databricks SQL identifiers are case-insensitive, but the cascade-drop
match in `_references_dropped` was case-sensitive. A metric such as
`COUNT(DISTINCT REGION_NAME)` therefore failed to match a dropped
`region_name` and survived as a dangling reference in the emitted
Metric View.

Add `re.IGNORECASE` to both patterns in `_references_dropped` (the
`measure(<name>)` pattern and the bare-dimension token pattern). The
word-boundary guards are unchanged, so qualified `alias.col` references
are still not over-dropped. Adds the reported repro as a regression
test that fails without the fix.

Fixes #422

Co-authored-by: Isaac <no-reply@databricks.com>
---
 .../ossie_databricks/ossie_to_metric_view.py  |  6 +++--
 .../tests/test_ossie_to_metric_view.py        | 25 +++++++++++++++++++
 2 files changed, 29 insertions(+), 2 deletions(-)

diff --git a/converters/databricks/src/ossie_databricks/ossie_to_metric_view.py b/converters/databricks/src/ossie_databricks/ossie_to_metric_view.py
index de828bef..4bd538e5 100644
--- a/converters/databricks/src/ossie_databricks/ossie_to_metric_view.py
+++ b/converters/databricks/src/ossie_databricks/ossie_to_metric_view.py
@@ -590,9 +590,11 @@ def _references_dropped(expr, self_name, dropped_dims, dropped_measures):
     that merely shares a dropped dimension's name is not over-dropped. The one
     ambiguity the regex can't resolve without a SQL parser is a bare, unqualified
     *source column* sharing a dropped dimension's name -- there it errs on dropping.
+
+    Matching is case-insensitive, as Databricks SQL identifiers are case-insensitive.
     """
     for m in dropped_measures:
-        if re.search(r"measure\(\s*" + re.escape(m) + r"\s*\)", expr):
+        if re.search(r"measure\(\s*" + re.escape(m) + r"\s*\)", expr, re.IGNORECASE):
             return m
     for d in dropped_dims:
         # Match only a bare, unqualified token: the negative look-behind/ahead for a
@@ -600,7 +602,7 @@ def _references_dropped(expr, self_name, dropped_dims, dropped_measures):
         # qualified paths (`alias.name` / `name.col`), so a join alias or joined
         # column sharing a dropped name is not falsely cascade-dropped.
         if d != self_name and re.search(
-                r"(?<![\w.])" + re.escape(d) + r"(?![\w.])", expr):
+                r"(?<![\w.])" + re.escape(d) + r"(?![\w.])", expr, re.IGNORECASE):
             return d
     return None
 
diff --git a/converters/databricks/tests/test_ossie_to_metric_view.py b/converters/databricks/tests/test_ossie_to_metric_view.py
index 77fa8988..6d221fa1 100644
--- a/converters/databricks/tests/test_ossie_to_metric_view.py
+++ b/converters/databricks/tests/test_ossie_to_metric_view.py
@@ -272,6 +272,31 @@ def test_cascade_drop_downstream_dimension_reference():
     assert dims == ["keep"]   # region dropped; label cascade-dropped; keep survives
 
 
+def test_cascade_drop_matches_dropped_name_case_insensitively():
+    """Databricks SQL identifiers are case-insensitive, so a measure that references a
+    dropped field in a different case (COUNT(DISTINCT REGION_NAME) over a dropped
+    region_name) must cascade-drop rather than survive as a dangling reference."""
+    import yaml
+    ossie = yaml.safe_dump({
+        "version": exporter.OSSIE_VERSION,
+        "name": "m",
+        "datasets": [{"name": "d", "source": "c.s.t", "fields": [
+            {"name": "id", "expression": {"dialects": [{"dialect": "DATABRICKS", "expression": "id"}]}},
+            {"name": "region_name", "expression": {"dialects": [{"dialect": "T_SQL", "expression": "region_name"}]}},  # dropped: no DBX/ANSI
+        ]}],
+        "metrics": [
+            # references the dropped region_name in upper case
+            {"name": "region_count", "expression": {"dialects": [
+                {"dialect": "DATABRICKS", "expression": "COUNT(DISTINCT REGION_NAME)"}]}},
+        ],
+    })
+    out = parse(exporter.convert_ossie_to_metric_view(ossie))
+    measures = [m["name"] for m in out.get("measures", [])]
+    dims = [d["name"] for d in out.get("dimensions", [])]
+    assert measures == []      # region_count cascade-dropped despite the case mismatch
+    assert dims == ["id"]      # the unrelated dimension survives
+
+
 def test_orientation_unverifiable_when_to_side_has_no_key_warns():
     """If the `from` columns are a declared key but the `to` side declares no key, the
     from/to orientation can't be verified; the converter leaves it as-is (no reorient)

From 0103333b9cdf2240ded5f38b9c051ee7b98e9ab9 Mon Sep 17 00:00:00 2001
From: Chris Eubank <108756251+christianeu-db@users.noreply.github.com>
Date: Sat, 19 Sep 2026 21:11:39 +0000
Subject: [PATCH 2/2] fix(databricks): exclude function calls from cascade-drop
 match

Address review feedback on #428:
- Exclude function-call tokens (`NAME(...)`) from the bare-dimension match,
  so a dropped dim named like a SQL function (e.g. `count`) does not falsely
  cascade-drop a surviving `COUNT(...)`. This also fixes the pre-existing
  exact-case collision.
- Case-fold the self-reference guard on both the dimension and
  `measure(<name>)` branches, so a column is never dropped for referencing
  itself under a different case.
- Add regression tests for both (each fails without its fix).

Co-authored-by: Isaac <no-reply@databricks.com>
---
 .../ossie_databricks/ossie_to_metric_view.py  | 34 +++++++++-----
 .../tests/test_ossie_to_metric_view.py        | 47 +++++++++++++++++++
 2 files changed, 69 insertions(+), 12 deletions(-)

diff --git a/converters/databricks/src/ossie_databricks/ossie_to_metric_view.py b/converters/databricks/src/ossie_databricks/ossie_to_metric_view.py
index 4bd538e5..cd722765 100644
--- a/converters/databricks/src/ossie_databricks/ossie_to_metric_view.py
+++ b/converters/databricks/src/ossie_databricks/ossie_to_metric_view.py
@@ -587,22 +587,32 @@ def _references_dropped(expr, self_name, dropped_dims, dropped_measures):
     Measures are only referenceable via `measure(<name>)` (exact). Dimensions are
     referenced by their bare, *unqualified* name: a name that is part of a qualified
     path (`alias.name` or `name.col`) is ignored, so a join alias or joined column
-    that merely shares a dropped dimension's name is not over-dropped. The one
-    ambiguity the regex can't resolve without a SQL parser is a bare, unqualified
-    *source column* sharing a dropped dimension's name -- there it errs on dropping.
-
-    Matching is case-insensitive, as Databricks SQL identifiers are case-insensitive.
+    that merely shares a dropped dimension's name is not over-dropped. A bare token
+    immediately followed by `(` is a function/keyword call (e.g. `COUNT(...)`), never
+    a dimension reference, so it is excluded too.
+
+    Without a real SQL parser the bare-name match still can't tell an identifier from
+    a same-spelled keyword that is *not* a call (a type in `CAST(x AS DATE)`, a unit
+    in `EXTRACT(YEAR FROM d)` / `INTERVAL 1 DAY`, `CASE ... END`, `DISTINCT`) or from
+    text inside a string literal; a dropped dimension named like one of those errs on
+    dropping. This is the residual the paren-guard does not close.
+
+    Matching is case-insensitive, as Databricks SQL identifiers are case-insensitive;
+    the self-reference guard is case-folded to match, so a measure or dimension is
+    never dropped for referencing itself under a different case.
     """
     for m in dropped_measures:
-        if re.search(r"measure\(\s*" + re.escape(m) + r"\s*\)", expr, re.IGNORECASE):
+        if m.lower() != self_name.lower() and re.search(
+                r"measure\(\s*" + re.escape(m) + r"\s*\)", expr, re.IGNORECASE):
             return m
     for d in dropped_dims:
-        # Match only a bare, unqualified token: the negative look-behind/ahead for a
-        # word char or `.` excludes both substrings of a larger identifier and
-        # qualified paths (`alias.name` / `name.col`), so a join alias or joined
-        # column sharing a dropped name is not falsely cascade-dropped.
-        if d != self_name and re.search(
-                r"(?<![\w.])" + re.escape(d) + r"(?![\w.])", expr, re.IGNORECASE):
+        # Match only a bare, unqualified token that is not a function call: the
+        # negative look-behind/ahead for a word char or `.` excludes substrings of a
+        # larger identifier and qualified paths (`alias.name` / `name.col`), and the
+        # trailing `(?!\s*\()` excludes `NAME(...)` calls, so a dropped dim named e.g.
+        # `count` does not falsely match a surviving `COUNT(...)`.
+        if d.lower() != self_name.lower() and re.search(
+                r"(?<![\w.])" + re.escape(d) + r"(?![\w.])(?!\s*\()", expr, re.IGNORECASE):
             return d
     return None
 
diff --git a/converters/databricks/tests/test_ossie_to_metric_view.py b/converters/databricks/tests/test_ossie_to_metric_view.py
index 6d221fa1..a9347fc7 100644
--- a/converters/databricks/tests/test_ossie_to_metric_view.py
+++ b/converters/databricks/tests/test_ossie_to_metric_view.py
@@ -297,6 +297,53 @@ def test_cascade_drop_matches_dropped_name_case_insensitively():
     assert dims == ["id"]      # the unrelated dimension survives
 
 
+def test_cascade_drop_does_not_over_drop_function_named_like_dropped_field():
+    """A dropped field whose name collides with a SQL function/keyword token in a
+    surviving expression must NOT cascade-drop it. `COUNT(...)` is a function call,
+    not a reference to a dropped `count` dimension. Because identifiers are matched
+    case-insensitively, the collision would otherwise fire on any case, so the match
+    must exclude function-call tokens (`NAME(...)`)."""
+    import yaml
+    ossie = yaml.safe_dump({
+        "version": exporter.OSSIE_VERSION,
+        "name": "m",
+        "datasets": [{"name": "d", "source": "c.s.t", "fields": [
+            {"name": "id", "expression": {"dialects": [{"dialect": "DATABRICKS", "expression": "id"}]}},
+            # dropped (no DBX/ANSI); its bare name collides with the COUNT() function
+            {"name": "count", "expression": {"dialects": [{"dialect": "T_SQL", "expression": "count"}]}},
+        ]}],
+        "metrics": [
+            {"name": "total", "expression": {"dialects": [
+                {"dialect": "DATABRICKS", "expression": "COUNT(DISTINCT id)"}]}},
+        ],
+    })
+    out = parse(exporter.convert_ossie_to_metric_view(ossie))
+    measures = [m["name"] for m in out.get("measures", [])]
+    # `total` is not cascade-dropped: COUNT(...) is a function call, not a `count` ref.
+    assert measures == ["total"]
+
+
+def test_cascade_drop_does_not_drop_self_reference_differing_only_in_case():
+    """A dropped field and a surviving dimension whose names differ only in case can
+    coexist (a dropped field is not deduped against survivors). The survivor's bare
+    self-reference must not be read as a reference to the dropped field, so the
+    self-guard is case-folded and the survivor is kept rather than cascade-dropped."""
+    import yaml
+    ossie = yaml.safe_dump({
+        "version": exporter.OSSIE_VERSION,
+        "name": "m",
+        "datasets": [{"name": "d", "source": "c.s.t", "fields": [
+            # dropped (no DBX/ANSI); name differs from the survivor only in case
+            {"name": "REGION", "expression": {"dialects": [{"dialect": "T_SQL", "expression": "REGION"}]}},
+            {"name": "region", "expression": {"dialects": [{"dialect": "DATABRICKS", "expression": "region"}]}},
+        ]}],
+    })
+    out = parse(exporter.convert_ossie_to_metric_view(ossie))
+    dims = [d["name"] for d in out.get("dimensions", [])]
+    # `region` survives: its bare `region` is a self-reference, not a ref to dropped REGION
+    assert dims == ["region"]
+
+
 def test_orientation_unverifiable_when_to_side_has_no_key_warns():
     """If the `from` columns are a declared key but the `to` side declares no key, the
     from/to orientation can't be verified; the converter leaves it as-is (no reorient)