getsentry · phacops · Jun 25, 2026 · Jun 25, 2026 · Jun 25, 2026 · Jun 25, 2026
@@ -89,6 +89,37 @@ def attribute_key_to_expression(attr_key: AttributeKey) -> Expression:
         raise BadSnubaRPCRequestException(str(e)) from e
 
 
+_SEMVER_COMPONENT_COUNT = 4  # major.minor.patch.build
+
+SEMVER_SORT_ATTRIBUTES: frozenset[str] = frozenset({"sentry.release"})
+
+
+def semver_sort_key(expr: Expression, alias: str | None = None) -> Expression:
+    """Return a Tuple(Array(UInt32), UInt8) sort key for semantic-version ORDER BY.
+
+    Strips a leading 'package@' prefix, isolates the release part (before '-'),
+    maps each dot-component to UInt32, pads to 4 elements so "1.2" == "1.2.0",
+    and adds a stability flag (0=prerelease, 1=stable) so prerelease versions sort
+    before their corresponding stable release.  Works on Altinity 25.3/25.8.
+    """
+    x = Argument(None, "x")
+    # sentry.release is coalesced from multiple attribute columns and therefore
+    # returns Nullable(String).  ClickHouse forbids Nullable(Array(…)), so strip
+    # the nullable wrapper before applying any string → array functions.
+    non_null = f.ifNull(expr, literal(""))
+    version_no_prefix = f.arrayElement(f.splitByChar(literal("@"), non_null), literal(-1))
+    release_part = f.arrayElement(f.splitByChar(literal("-"), version_no_prefix), literal(1))
+    numeric_key = f.arrayResize(
+        f.arrayMap(
+            Lambda(None, ("x",), f.toUInt32OrZero(x)),
+            f.splitByChar(literal("."), release_part),
+        ),
+        literal(_SEMVER_COMPONENT_COUNT),
+    )
+    is_stable = f.equals(f.position(version_no_prefix, literal("-")), literal(0))
+    return FunctionCall(alias, "tuple", (numeric_key, is_stable))
+
+
 def _trace_item_filter_key_expression(
     attr_to_key_expression_callable: Callable[[AttributeKey], Expression],
     key: AttributeKey,

@@ -18,7 +18,11 @@
 from snuba.query.dsl import Functions as f
 from snuba.query.dsl import column, literal
 from snuba.query.expressions import Expression
-from snuba.web.rpc.common.common import attribute_key_to_expression
+from snuba.web.rpc.common.common import (
+    SEMVER_SORT_ATTRIBUTES,
+    attribute_key_to_expression,
+    semver_sort_key,
+)
 from snuba.web.rpc.storage_routing.routing_strategies.storage_routing import TimeWindow
 
 
@@ -99,9 +103,23 @@ def get_filters(self) -> Expression | None:
                     )
         # Assumes everything in the ORDER BY is ordered by DESC
         if column_names:
-            res = f.less(
-                f.tuple(*(column(c_name) for c_name in column_names)), f.tuple(*column_values)
-            )
+            col_exprs = []
+            val_exprs = []
+            for c_name, c_value in zip(column_names, column_values, strict=True):
+                # c_name is the attribute expression alias: "{attr}.{Type.Name(type)}"
+                # For semver attributes (e.g. sentry.release_TYPE_STRING), apply the
+                # same semver sort key on both sides so the page boundary comparison
+                # uses the same ordering as ORDER BY.
+                attr_name = (
+                    c_name.removesuffix("_TYPE_STRING") if c_name.endswith("_TYPE_STRING") else None
+                )
+                if attr_name in SEMVER_SORT_ATTRIBUTES:
+                    col_exprs.append(semver_sort_key(column(c_name)))
+                    val_exprs.append(semver_sort_key(c_value))
+                else:
+                    col_exprs.append(column(c_name))
+                    val_exprs.append(c_value)
+            res = f.less(f.tuple(*col_exprs), f.tuple(*val_exprs))
             return res
         return None
 

@@ -60,10 +60,12 @@
 from snuba.utils.metrics.timer import Timer
 from snuba.web.query import run_query
 from snuba.web.rpc.common.common import (
+    SEMVER_SORT_ATTRIBUTES,
     add_existence_check_to_subscriptable_references,
     attribute_key_to_expression,
     base_conditions_and,
     get_field_existence_expression,
+    semver_sort_key,
     timestamp_in_range_condition,
     trace_item_filters_to_expression,
     treeify_or_and_conditions,
@@ -276,7 +278,7 @@ def aggregation_filter_to_expression(
             raise BadSnubaRPCRequestException(f"Unsupported aggregation filter type: {default}")
 
 
-def _groupby_order_by_expression(attr_key: AttributeKey) -> Expression:
+def _groupby_order_by_expression(attr_key: AttributeKey, for_order_by: bool = False) -> Expression:
     """
     Maps an attribute key used in GROUP BY / ORDER BY to its expression.
 
@@ -285,10 +287,17 @@ def _groupby_order_by_expression(attr_key: AttributeKey) -> Expression:
     while keeping the cast valid as a function of the grouped column. TYPE_ARRAY keys are
     rejected upstream (see _validate_select_and_groupby / _validate_order_by), so they
     never reach here.
+
+    For `SEMVER_SORT_ATTRIBUTES` (e.g. `sentry.release`), the ORDER BY uses
+    a semver tuple key while GROUP BY keeps the raw expression.  ClickHouse
+    accepts ORDER BY on a function of a GROUP BY key, so the two can differ here.
     """
     if attr_key.name == "sentry.timestamp":
         return snuba_column("timestamp")
-    return attribute_key_to_expression(attr_key)
+    base = attribute_key_to_expression(attr_key)
+    if for_order_by and attr_key.name in SEMVER_SORT_ATTRIBUTES:
+        return semver_sort_key(base)
+    return base
 
 
 def _convert_order_by(
@@ -339,11 +348,12 @@ def _convert_order_by(
             # no-groupby branch above already expands to the full table sort key; this
             # covers `sentry.timestamp` ordering anywhere else.) GROUP BY uses the same
             # expression so an aggregation query that orders by `sentry.timestamp` stays
-            # valid.
+            # valid.  For `SEMVER_SORT_ATTRIBUTES`, `for_order_by=True` selects the semver
+            # tuple key here while GROUP BY keeps the raw expression.
             res.append(
                 OrderBy(
                     direction=direction,
-                    expression=_groupby_order_by_expression(x.column.key),
+                    expression=_groupby_order_by_expression(x.column.key, for_order_by=True),
                 )
             )
         elif x.column.HasField("conditional_aggregation"):

@@ -55,6 +55,7 @@
     dedupe_and_conditions,
     next_monday,
     prev_monday,
+    semver_sort_key,
     trace_item_filters_to_expression,
     treeify_or_and_conditions,
     use_array_map_columns,
@@ -1306,3 +1307,31 @@ def test_like_wildcard_matches_present_not_absent(self) -> None:
     def test_not_like_wildcard_matches_only_absent(self) -> None:
         # Present rows all `like '%'`, so only the absent key survives NOT LIKE.
         assert self._execute(ComparisonFilter.OP_NOT_LIKE, value="%") == ["green"]
+
+
+class TestSemverSortKey:
+    def test_expression_structure(self) -> None:
+        from snuba.query.dsl import column as snuba_column
+
+        expr = semver_sort_key(snuba_column("release"))
+        assert isinstance(expr, FunctionCall)
+        assert expr.function_name == "tuple"
+        assert len(expr.parameters) == 2
+        numeric_key_expr, is_stable_expr = expr.parameters
+        assert isinstance(numeric_key_expr, FunctionCall)
+        assert numeric_key_expr.function_name == "arrayResize"
+        assert isinstance(is_stable_expr, FunctionCall)
+        assert is_stable_expr.function_name == "equals"
+
+    def test_alias_is_forwarded(self) -> None:
+        from snuba.query.dsl import column as snuba_column
+
+        expr = semver_sort_key(snuba_column("release"), alias="semver_key")
+        assert isinstance(expr, FunctionCall)
+        assert expr.alias == "semver_key"
+
+    def test_no_alias_by_default(self) -> None:
+        from snuba.query.dsl import column as snuba_column
+
+        expr = semver_sort_key(snuba_column("release"))
+        assert expr.alias is None
@@ -4610,6 +4610,119 @@ def test_order_by_bug() -> None:
         _validate_order_by(message)
 
 
+@pytest.mark.clickhouse_db
+@pytest.mark.redis_db
+class TestSemverSorting:
+    """ORDER BY sentry.release uses the tuple(arrayResize(…), is_stable) key so
+    versions sort numerically (1.2.9 before 1.2.10) with pre-releases before
+    their corresponding stable release.
+    """
+
+    _RELEASES = [
+        "1.2.9",
+        "1.2.10",
+        "1.2.3",
+        "1.2.3-beta.1",
+        "1.2.2",
+        "my-pkg@2.0.0",
+        "1.2",
+        "1.2.0",
+    ]
+
+    @pytest.fixture(autouse=True)
+    def _setup(self, clickhouse_db: None, redis_db: None) -> None:
+        for i, release in enumerate(self._RELEASES):
+            write_eap_item(
+                start_timestamp=BASE_TIME + timedelta(minutes=i),
+                raw_attributes={"sentry.release": release, "semver_test_marker": "1"},
+            )
+
+    def _query_releases(self, descending: bool = False) -> list[str]:
+        message = TraceItemTableRequest(
+            meta=RequestMeta(
+                project_ids=[1],
+                organization_id=1,
+                cogs_category="something",
+                referrer="something",
+                start_timestamp=START_TIMESTAMP,
+                end_timestamp=END_TIMESTAMP,
+                trace_item_type=TraceItemType.TRACE_ITEM_TYPE_SPAN,
+            ),
+            filter=TraceItemFilter(
+                exists_filter=ExistsFilter(
+                    key=AttributeKey(type=AttributeKey.TYPE_STRING, name="semver_test_marker")
+                )
+            ),
+            columns=[
+                Column(key=AttributeKey(type=AttributeKey.TYPE_STRING, name="sentry.release"))
+            ],
+            order_by=[
+                TraceItemTableRequest.OrderBy(
+                    column=Column(
+                        key=AttributeKey(type=AttributeKey.TYPE_STRING, name="sentry.release")
+                    ),
+                    descending=descending,
+                )
+            ],
+            limit=len(self._RELEASES) + 10,
+        )
+        response = EndpointTraceItemTable().execute(message)
+        return [v.val_str for v in response.column_values[0].results]
+
+    def test_numeric_ordering(self) -> None:
+        releases = self._query_releases()
+        assert releases.index("1.2.9") < releases.index("1.2.10"), (
+            "1.2.9 must sort before 1.2.10 (numeric, not lexicographic)"
+        )
+
+    def test_prerelease_before_stable(self) -> None:
+        releases = self._query_releases()
+        assert releases.index("1.2.3-beta.1") < releases.index("1.2.3"), (
+            "prerelease 1.2.3-beta.1 must sort before stable 1.2.3"
+        )
+
+    def test_prerelease_of_newer_after_older_stable(self) -> None:
+        releases = self._query_releases()
+        assert releases.index("1.2.3-beta.1") > releases.index("1.2.2"), (
+            "prerelease 1.2.3-beta.1 must sort after older stable 1.2.2"
+        )
+
+    def test_package_prefix_stripped(self) -> None:
+        releases = self._query_releases()
+        assert releases.index("my-pkg@2.0.0") > releases.index("1.2.10"), (
+            "my-pkg@2.0.0 should sort as version 2.0.0 (after 1.x)"
+        )
+
+    def test_length_normalisation(self) -> None:
+        releases = self._query_releases()
+        idx_12 = releases.index("1.2")
+        idx_120 = releases.index("1.2.0")
+        assert abs(idx_12 - idx_120) <= 1, (
+            "1.2 and 1.2.0 should sort as equal (both normalise to [1,2,0,0])"
+        )
+
+    def test_desc_is_reverse_of_asc(self) -> None:
+        asc = self._query_releases(descending=False)
+        desc = self._query_releases(descending=True)
+        # "1.2" and "1.2.0" share the same sort key ([1,2,0,0], 1); ClickHouse
+        # may return them in either relative order within the tied pair.
+        # Collapse contiguous tied elements into a frozenset before comparing so
+        # the assertion is order-insensitive within ties.
+        TIED: frozenset[str] = frozenset({"1.2", "1.2.0"})
+
+        def _canonicalize(releases: list[str]) -> list[object]:
+            out: list[object] = []
+            for r in releases:
+                if r in TIED:
+                    if not out or out[-1] != TIED:
+                        out.append(TIED)
+                else:
+                    out.append(r)
+            return out
+
+        assert _canonicalize(asc) == _canonicalize(list(reversed(desc)))
+
+
 def test_uniq_with_default_value_double_casts_to_float64() -> None:
     """
     Regression test: FUNCTION_UNIQ (uniqIfOrNull) returns UInt64, which is