fix(translator): Hash identity-key percentage splits without a context identity

A PERCENTAGE_SPLIT keyed on the identity (implicit `$.identity.key`,
`$.identity.key`, or `$.identity.identifier`) compiled to FALSE when the
evaluation context carried no identity. But the translated predicate runs
per-row over IDENTITIES, where the identity-key and identifier columns are
always present, so it should hash the row column regardless of whether the
row-oriented context supplies an identity. The guard made row-oriented
callers (segment-membership counts/members) see every percentage-split
segment as empty.

Drop the eval-context identity guard for those three cases and emit the
per-row hash. Trait-keyed splits are unchanged.

No engine-test-data case translates a percentage split with an
identity-less context, so the SQL for every parity case is byte-identical
(the guard was always passing there) and no _XFAIL_CASE_NAMES entries are
needed. This does intentionally diverge from flag_engine's single-eval
"no identity -> False" for the identity-less case, which is correct for the
row-oriented SQL engine where every row is an identity.

beep boop
Claude-Session: https://claude.ai/code/session_01EgZ5iHpDASZzCapiHRxHLB

Author: khvn26

src/flagsmith_sql_flag_engine/translator.py

@@ -435,19 +435,14 @@ def translate_condition(cond: SegmentCondition, ctx: TranslateContext) -> str |
         identity: dict[str, object] = ctx.evaluation_context.get("identity") or {}  # type: ignore[assignment]
         kind = classification.kind
         if not prop:
-            # Implicit `$.identity.key` — engine returns False when no
-            # identity, or when the identity lacks `key`. The engine
-            # never synthesises one from env+identifier.
-            if not identity.get("key"):
-                return "FALSE"
+            # Implicit `$.identity.key`. The key is always present in the store,
+            # so the split is translatable whether or not the evaluation context
+            # carries an identity. This intentionally diverges from the engine's
+            # "no identity → False" verdict.
             value_expr = ctx.dialect.cast_string(ctx.identity_key_expr)
         elif kind == "key":
-            if not identity.get("key"):
-                return "FALSE"
             value_expr = ctx.dialect.cast_string(ctx.jsonpath_expr("$.identity.key"))
         elif kind == "identifier":
-            if not identity.get("identifier"):
-                return "FALSE"
             value_expr = ctx.dialect.cast_string(ctx.jsonpath_expr("$.identity.identifier"))
         elif kind == "identity_object":
             # PERCENTAGE_SPLIT on `$.identity` — the whole dict. Engine

tests/test_translator_unit.py

@@ -542,9 +542,10 @@ def _ctx_identity_without(field: str) -> TranslateContext:
     )
 
 
-def test_translate_segment__percentage_split_implicit_key_no_identity__compiles_to_false() -> None:
-    # Given a PERCENTAGE_SPLIT with no property (implicit `$.identity.key`) and an eval
-    # context with no identity
+def test_translate_segment__percentage_split_implicit_key_no_identity__inlines_md5() -> None:
+    # Given a PERCENTAGE_SPLIT with no property (implicit `$.identity.key`) and an
+    # eval context with no identity — the row-oriented case (e.g. segment-membership
+    # counting over the whole IDENTITIES table)
     seg: SegmentContext = {
         "key": "ps2",
         "name": "s",
@@ -556,12 +557,19 @@ def test_translate_segment__percentage_split_implicit_key_no_identity__compiles_
         ],
     }
 
-    # When / Then the predicate collapses to FALSE — engine returns False without identity
-    assert translate_segment(seg, _ctx_no_identity()) == "((FALSE))"
+    # When translated
+    sql = translate_segment(seg, _ctx_no_identity())
 
+    # Then it hashes the per-row identity-key column rather than folding to
+    # FALSE — the row supplies the subject, so a context identity is not needed
+    assert sql is not None
+    assert "FALSE" not in sql
+    assert "MD5(" in sql
+    assert "<= 50.0" in sql
 
-def test_translate_segment__percentage_split_identity_key_missing__compiles_to_false() -> None:
-    # Given the eval context's identity has no `key`
+
+def test_translate_segment__percentage_split_key_no_context_identity__inlines_md5() -> None:
+    # Given a PERCENTAGE_SPLIT on `$.identity.key` and a context identity without `key`
     seg: SegmentContext = {
         "key": "ps3",
         "name": "s",
@@ -575,14 +583,16 @@ def test_translate_segment__percentage_split_identity_key_missing__compiles_to_f
         ],
     }
 
-    # When / Then the predicate collapses to FALSE
-    assert translate_segment(seg, _ctx_identity_without("key")) == "((FALSE))"
+    # When / Then it still hashes the per-row identity-key column
+    sql = translate_segment(seg, _ctx_identity_without("key"))
+    assert sql is not None
+    assert "FALSE" not in sql
+    assert "MD5(" in sql
 
 
-def test_translate_segment__percentage_split_identity_identifier_missing__compiles_to_false() -> (
-    None
-):
-    # Given the eval context's identity has no `identifier`
+def test_translate_segment__percentage_split_identifier_no_context_identity__inlines_md5() -> None:
+    # Given a PERCENTAGE_SPLIT on `$.identity.identifier` and a context identity
+    # without `identifier`
     seg: SegmentContext = {
         "key": "ps4",
         "name": "s",
@@ -600,8 +610,11 @@ def test_translate_segment__percentage_split_identity_identifier_missing__compil
         ],
     }
 
-    # When / Then the predicate collapses to FALSE
-    assert translate_segment(seg, _ctx_identity_without("identifier")) == "((FALSE))"
+    # When / Then it still hashes the per-row identifier column
+    sql = translate_segment(seg, _ctx_identity_without("identifier"))
+    assert sql is not None
+    assert "FALSE" not in sql
+    assert "MD5(" in sql
 
 
 def test_translate_segment__percentage_split_unknown_jsonpath__returns_none() -> None: