From fe5e7458e90b45a4ae6ccd2e99916ff5c9617da4 Mon Sep 17 00:00:00 2001 From: Jonas Daniels Date: Thu, 15 Oct 2026 10:28:57 -0700 Subject: [PATCH] perf: walk tx.run results for unsafe integers only when one was parsed extract_zql_result walked every decoded result looking for an integer outside JavaScript's safe range, calling js_keys on each object. On a 10k-row result the walk cost more than json.loads itself. parse_int now sets a flag when it builds an _Unsafe, and the walk runs only when the flag is set. The error path and message are unchanged. On the 10k-row bench against @rocicorp/zero 1.10.0 (asyncpg), flat went from 2.17x TS to 0.90x and related from 1.51x to 0.95x. The SQL tier now reaches the walk only through the pinned counter query, so two unit tests cover the rest of it: one checks the path in the message, and one checks that an unsafe integer replaced by a duplicate key is still ignored. Co-Authored-By: Claude Opus 5.5 --- src/zero_server/server/pg_query_executor.py | 20 +++++++++++++------- tests/unit/test_api.py | 15 +++++++++++++++ 2 files changed, 28 insertions(+), 7 deletions(-) diff --git a/src/zero_server/server/pg_query_executor.py b/src/zero_server/server/pg_query_executor.py index 848cc66..e7b9db5 100644 --- a/src/zero_server/server/pg_query_executor.py +++ b/src/zero_server/server/pg_query_executor.py @@ -23,11 +23,6 @@ class _Unsafe(int): """An integer JavaScript cannot hold exactly. Upstream parses it as a bigint and refuses it.""" -def _parse_int(text: str) -> int: - value = int(text) - return _Unsafe(value) if abs(value) > _MAX_SAFE else value - - def _parse_float(text: str) -> int | float: """A whole number written with a fraction, as `numeric` epoch milliseconds are, comes back an `int`. @@ -53,8 +48,19 @@ def _path_to_unsafe(value: Any) -> str | None: def extract_zql_result(rows: list[Row]) -> Any: - result = json.loads(rows[0][ZQL_RESULT_KEY], parse_int=_parse_int, parse_float=_parse_float) - if (path := _path_to_unsafe(result)) is not None: + unsafe = False + + def parse_int(text: str) -> int: + nonlocal unsafe + value = int(text) + if abs(value) <= _MAX_SAFE: + return value + unsafe = True + return _Unsafe(value) + + result = json.loads(rows[0][ZQL_RESULT_KEY], parse_int=parse_int, parse_float=_parse_float) + # A duplicate key can drop a parsed unsafe integer, so the walk may still find none. + if unsafe and (path := _path_to_unsafe(result)) is not None: raise Exception(f"Value exceeds safe Number range. {path}") return result diff --git a/tests/unit/test_api.py b/tests/unit/test_api.py index 7e30c74..4e73b16 100644 --- a/tests/unit/test_api.py +++ b/tests/unit/test_api.py @@ -238,3 +238,18 @@ def test_server_ast_maps_to_server_names() -> None: ast: Any = server_ast(create_builder(schema).issue.where("ownerID", "u"), schema).to_json() assert ast["table"] == "issues" assert ast["where"]["left"]["name"] == "owner_id" + + +def test_zql_result_names_the_first_unsafe_integer() -> None: + from zero_server.server.pg_query_executor import extract_zql_result + + text = '[{"n": [1], "m": [2, -9007199254740993]}, {"n": 9007199254740993}]' + with pytest.raises(Exception, match=r"^Value exceeds safe Number range\. \[0\]\['m'\]\[1\] = -9007199254740993$"): + extract_zql_result([{"zql_result": text}]) + + +def test_zql_result_ignores_an_unsafe_integer_a_duplicate_key_replaced() -> None: + from zero_server.server.pg_query_executor import extract_zql_result + + text = '{"n": 9007199254740993, "n": 9007199254740991}' + assert extract_zql_result([{"zql_result": text}]) == {"n": 9007199254740991}