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..9fb7482a 100644
--- a/converters/databricks/src/ossie_databricks/ossie_to_metric_view.py
+++ b/converters/databricks/src/ossie_databricks/ossie_to_metric_view.py
@@ -581,26 +581,43 @@ def _convert_metric(metric, fact, seen_names):
     return measure
 
 
-def _references_dropped(expr, self_name, dropped_dims, dropped_measures):
+def _references_dropped(expr, self_name, self_kind, dropped_dims, dropped_measures):
     """Return a dropped name referenced by `expr`, or None.
 
     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.
+    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, and scoped to `self_kind`: a
+    field is exempt only from referencing itself within its own kind. A measure that
+    merely shares a dropped dimension's name (or vice versa) is a different object, so
+    it is still checked and cascade-dropped rather than exempted as a self-reference.
     """
     for m in dropped_measures:
-        if re.search(r"measure\(\s*" + re.escape(m) + r"\s*\)", expr):
+        if self_kind == "measure" and m.lower() == self_name.lower():
+            continue
+        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
-        # 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):
+        if self_kind == "dimension" and d.lower() == self_name.lower():
+            continue
+        # 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 re.search(
+                r"(?<![\w.])" + re.escape(d) + r"(?![\w.])(?!\s*\()", expr, re.IGNORECASE):
             return d
     return None
 
@@ -618,7 +635,7 @@ def _cascade_drop(dimensions, measures, dropped_dims, dropped_measures):
             survivors = []
             for col in coll:
                 ref = _references_dropped(
-                    col["expr"], col["name"], dropped_dims, dropped_measures)
+                    col["expr"], col["name"], kind, dropped_dims, dropped_measures)
                 if ref is not None:
                     _warn(f"{kind} '{col['name']}'",
                           f"references dropped '{ref}'; dropping (downstream of a dropped field/metric)")
diff --git a/converters/databricks/tests/test_ossie_to_metric_view.py b/converters/databricks/tests/test_ossie_to_metric_view.py
index 77fa8988..d10f8f32 100644
--- a/converters/databricks/tests/test_ossie_to_metric_view.py
+++ b/converters/databricks/tests/test_ossie_to_metric_view.py
@@ -272,6 +272,103 @@ 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_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_cascade_drop_measure_named_like_dropped_dimension_is_dropped():
+    """A measure sharing a dropped dimension's name (case-insensitively) is not a
+    self-reference: the self-guard is scoped to the field's own kind, so the measure's
+    reference to the dropped dimension is detected and the measure is cascade-dropped
+    rather than emitted with 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"}]}},
+            # dropped dimension; the measure below shares its name only in case
+            {"name": "Region", "expression": {"dialects": [{"dialect": "T_SQL", "expression": "Region"}]}},
+        ]}],
+        "metrics": [
+            {"name": "region", "expression": {"dialects": [{"dialect": "DATABRICKS", "expression": "SUM(Region)"}]}},
+        ],
+    })
+    out = parse(exporter.convert_ossie_to_metric_view(ossie))
+    measures = [m["name"] for m in out.get("measures", [])]
+    # `region` references the dropped `Region` dimension, so it is cascade-dropped
+    # rather than exempted as a false cross-kind self-reference.
+    assert "region" not in measures
+
+
 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)