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. 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.

This intentionally diverges from flag_engine's single-eval "no identity ->
False" for the identity-less context, which is correct for the row-oriented
SQL engine where every row is an identity; the one engine-test-data case
that exercises it (test_percentage_split__no_identity_key__should_match) is
added to the ClickHouse harness's _XFAIL_CASE_NAMES. The translator unit
tests assert the full emitted SQL.

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/harnesses/clickhouse.py

@@ -39,6 +39,12 @@
     # condition, so we accept the divergence on this niche shape
     # (`$.`-prefixed trait names) and let callers fall back to the engine.
     "test_jsonpath_like_trait__existing_jsonpath__should_match_trait",
+    # Engine returns False for a PERCENTAGE_SPLIT when the eval context has
+    # no identity key. The SQL engine intentionally diverges: it runs over
+    # IDENTITIES rows where the identity key always exists, so it hashes the
+    # row's key rather than folding to FALSE — the behaviour row-oriented
+    # callers (segment-membership counts/members) need.
+    "test_percentage_split__no_identity_key__should_match",
 }
 
 

tests/test_translator_unit.py

@@ -542,9 +542,24 @@ 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 _ps_sql(seg_key: str, col: str) -> str:
+    """The full PERCENTAGE_SPLIT predicate the ClickHouse dialect emits for
+    threshold 50: an MD5-mod-9999 hash of `i.<col>` salted by the segment key,
+    chunked into four 8-hex slices and combined."""
+    h = f"MD5('{seg_key}' || ',' || (toString(i.{col})))"
+    return (
+        f"(((modulo(reinterpretAsUInt32(reverse(substring({h}, 1, 4))) * 7291"
+        f" + reinterpretAsUInt32(reverse(substring({h}, 5, 4))) * 1897"
+        f" + reinterpretAsUInt32(reverse(substring({h}, 9, 4))) * 6835"
+        f" + reinterpretAsUInt32(reverse(substring({h}, 13, 4))), 9999)"
+        f" / 9998.0 * 100.0 <= 50.0)))"
+    )
+
+
+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 +571,16 @@ 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 == _ps_sql("ps2", "identity_key")
 
 
-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 +594,14 @@ 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 == _ps_sql("ps3", "identity_key")
 
 
-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 +619,9 @@ 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 == _ps_sql("ps4", "identifier")
 
 
 def test_translate_segment__percentage_split_unknown_jsonpath__returns_none() -> None: