refactor(state): fold simplify findings — reuse _insert_message_rows, share guards, chunk seeds

Simplify-pass folds on the #23254 salvage:

- REUSE (HIGH): append_messages_batch now delegates row serialization to
  the pre-existing _insert_message_rows helper (already shared by
  replace_messages / archive_and_compact / portability import) instead
  of adding a third serialization path (_prepare_message_row +
  _MESSAGE_INSERT_SQL are gone). One row-writer for every multi-row
  path; the row-ID return was consumed by no production caller, so the
  batch returns the inserted count.

- QUALITY (HIGH): the compression-lock + compression-closed admission
  guards are extracted into _check_transcript_write_guards, shared by
  append_message and append_messages_batch (previously duplicated 23
  lines that had already needed targeted fixes, #74478). The role-gated
  reasoning filtering is no longer duplicated in run_agent.py — it
  lives at its one site inside _insert_message_rows.

- EFFICIENCY (MEDIUM, measured): unbounded seed copies hold one BEGIN
  IMMEDIATE for seconds (10k rows ~= 2.4s; FTS triggers dominate) and
  monopolize the in-process write lock. append_messages_batch grows a
  chunk_rows param; all seed/copy call sites use chunk_rows=500. Same
  recovery semantics as the old per-row loops, bounded lock holds.

- REUSE (MEDIUM): the two remaining per-row branch-copy loops found by
  the pass (gateway/slash_commands.py /branch, hermes_cli
  cli_commands_mixin.py branch) are converted to chunked batches too
  (AsyncSessionDB's generic to_thread forwarder covers the async site).

Turn-flush benchmark unchanged after the refactor: 2.43 -> 0.87 ms
median per 5-message flush (64% faster).
This commit is contained in:
kshitij
2026-08-03 17:14:28 +05:30
committed by kshitij
parent 84146fb9c6
commit da6d9604dd
7 changed files with 265 additions and 310 deletions
+33 -24
View File
@@ -4632,30 +4632,39 @@ class GatewaySlashCommandsMixin:
logger.error("Failed to create branch session: %s", e)
return t("gateway.branch.create_failed", error=e)
# Copy conversation history to the new session
for msg in history:
try:
await self._session_db.append_message(
session_id=new_session_id,
role=msg.get("role", "user"),
content=msg.get("content"),
tool_name=msg.get("tool_name") or msg.get("name"),
tool_calls=msg.get("tool_calls"),
tool_call_id=msg.get("tool_call_id"),
finish_reason=msg.get("finish_reason"),
reasoning=msg.get("reasoning"),
reasoning_content=msg.get("reasoning_content"),
reasoning_details=msg.get("reasoning_details"),
codex_reasoning_items=msg.get("codex_reasoning_items"),
codex_message_items=msg.get("codex_message_items"),
# Keep the api_content sidecar so the branch's first turn
# replays the parent's exact wire bytes (warm provider
# prompt cache) instead of a full cold prefill.
api_content=extract_api_content_sidecar(msg),
timestamp=msg.get("timestamp"),
)
except Exception:
pass # Best-effort copy
# Copy conversation history to the new session in bounded-chunk
# transactions (see #23254): one txn per row was the removed
# write-amplification pattern, and a history can be hundreds of rows.
# Best-effort like the old loop — a failed copy still yields a
# usable (partial) branch.
try:
await self._session_db.append_messages_batch(
new_session_id,
[
{
"role": msg.get("role", "user"),
"content": msg.get("content"),
"tool_name": msg.get("tool_name") or msg.get("name"),
"tool_calls": msg.get("tool_calls"),
"tool_call_id": msg.get("tool_call_id"),
"finish_reason": msg.get("finish_reason"),
"reasoning": msg.get("reasoning"),
"reasoning_content": msg.get("reasoning_content"),
"reasoning_details": msg.get("reasoning_details"),
"codex_reasoning_items": msg.get("codex_reasoning_items"),
"codex_message_items": msg.get("codex_message_items"),
# Keep the api_content sidecar so the branch's first turn
# replays the parent's exact wire bytes (warm provider
# prompt cache) instead of a full cold prefill.
"api_content": extract_api_content_sidecar(msg),
"timestamp": msg.get("timestamp"),
}
for msg in history
],
chunk_rows=500,
)
except Exception:
pass # Best-effort copy
# Set title
try:
+26 -19
View File
@@ -1171,25 +1171,32 @@ class CLICommandsMixin:
_cprint(f" Failed to create branch session: {e}")
return
# Copy conversation history to the new session
for msg in self.conversation_history:
try:
self._session_db.append_message(
session_id=new_session_id,
role=msg.get("role", "user"),
content=msg.get("content"),
tool_name=msg.get("tool_name") or msg.get("name"),
tool_calls=msg.get("tool_calls"),
tool_call_id=msg.get("tool_call_id"),
reasoning=msg.get("reasoning"),
# Keep the api_content sidecar so the branch's first turn
# replays the parent's exact wire bytes (warm provider
# prompt cache) instead of a full cold prefill.
api_content=extract_api_content_sidecar(msg),
timestamp=msg.get("timestamp"),
)
except Exception:
pass # Best-effort copy
# Copy conversation history to the new session in bounded-chunk
# transactions (see #23254) instead of one txn per row. Best-effort
# like the old loop — a failed copy still yields a usable branch.
try:
self._session_db.append_messages_batch(
new_session_id,
[
{
"role": msg.get("role", "user"),
"content": msg.get("content"),
"tool_name": msg.get("tool_name") or msg.get("name"),
"tool_calls": msg.get("tool_calls"),
"tool_call_id": msg.get("tool_call_id"),
"reasoning": msg.get("reasoning"),
# Keep the api_content sidecar so the branch's first turn
# replays the parent's exact wire bytes (warm provider
# prompt cache) instead of a full cold prefill.
"api_content": extract_api_content_sidecar(msg),
"timestamp": msg.get("timestamp"),
}
for msg in self.conversation_history
],
chunk_rows=500,
)
except Exception:
pass # Best-effort copy
# Set title on the branch
try:
+146 -227
View File
@@ -6001,116 +6001,38 @@ class SessionDB(SessionSearchMixin, SessionSchemaMixin, SessionPortabilityMixin)
)
return None
# INSERT column list shared by append_message and append_messages_batch so
# the row shape can never drift between the single and batched writers.
_MESSAGE_INSERT_SQL = (
"INSERT INTO messages (session_id, role, content, tool_call_id, "
"tool_calls, tool_name, effect_disposition, timestamp, token_count, finish_reason, "
"reasoning, reasoning_content, reasoning_details, codex_reasoning_items, "
"codex_message_items, platform_message_id, observed, active, api_content, display_kind, display_metadata) "
"VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)"
)
def _check_transcript_write_guards(
self, conn, session_id: str, compression_lock_holder: Optional[str]
) -> None:
"""Transcript-append admission checks, run INSIDE the write txn.
def _prepare_message_row(
self,
*,
session_id: str,
role: str,
content: Any = None,
tool_name: Optional[str] = None,
tool_calls: Any = None,
tool_call_id: Optional[str] = None,
token_count: Optional[int] = None,
finish_reason: Optional[str] = None,
reasoning: Optional[str] = None,
reasoning_content: Optional[str] = None,
reasoning_details: Any = None,
codex_reasoning_items: Any = None,
codex_message_items: Any = None,
platform_message_id: Optional[str] = None,
observed: bool = False,
effect_disposition: Optional[str] = None,
timestamp: Any = None,
api_content: Optional[str] = None,
display_kind: Optional[str] = None,
display_metadata: Optional[Dict[str, Any]] = None,
) -> Tuple[tuple, int]:
"""Serialize one message into ``_MESSAGE_INSERT_SQL`` bind params.
Runs entirely OUTSIDE the write transaction (JSON encoding, surrogate
scrubbing, timestamp coercion), so batched flushes keep the BEGIN
IMMEDIATE window as short as possible. Returns ``(params,
num_tool_calls)`` where ``num_tool_calls`` feeds the session counter
update.
Shared by :meth:`append_message` and :meth:`append_messages_batch` so
the two writers can never diverge on these correctness invariants
(this guard has already needed targeted fixes — see the #74478
patience note below).
"""
# Display metadata is presentation-only and never changes the model
# context role/content replayed to providers.
display_metadata_json = self._encode_display_metadata(display_metadata)
# Serialize structured fields to JSON before entering the write txn
reasoning_details_json = (
json.dumps(reasoning_details)
if reasoning_details else None
)
codex_items_json = (
json.dumps(codex_reasoning_items)
if codex_reasoning_items else None
)
codex_message_items_json = (
json.dumps(codex_message_items)
if codex_message_items else None
)
# tool_calls may arrive as a Python list (from the live agent) or
# as a JSON string (from import/export). Parse first to avoid
# double-encoding.
if isinstance(tool_calls, str):
try:
tool_calls = json.loads(tool_calls)
except (json.JSONDecodeError, TypeError):
tool_calls = []
tool_calls_json = json.dumps(tool_calls) if tool_calls else None
# Multimodal content (list of parts) must be JSON-encoded: sqlite3
# cannot bind list/dict parameters directly.
stored_content = self._encode_content(content)
message_timestamp = time.time()
if timestamp is not None:
try:
if hasattr(timestamp, "timestamp"):
message_timestamp = float(timestamp.timestamp())
else:
message_timestamp = float(timestamp)
except (TypeError, ValueError):
logger.debug("Ignoring invalid explicit message timestamp: %r", timestamp)
# Pre-compute tool call count
num_tool_calls = 0
if tool_calls is not None:
num_tool_calls = len(tool_calls) if isinstance(tool_calls, list) else 1
params = (
session_id,
role,
stored_content,
tool_call_id,
tool_calls_json,
_scrub_surrogates(tool_name),
effect_disposition,
message_timestamp,
token_count,
finish_reason,
_scrub_surrogates(reasoning),
_scrub_surrogates(reasoning_content),
reasoning_details_json,
codex_items_json,
codex_message_items_json,
platform_message_id,
1 if observed else 0,
1,
_scrub_surrogates(api_content) if isinstance(api_content, str) else None,
_scrub_surrogates(display_kind) if isinstance(display_kind, str) else None,
display_metadata_json,
)
return params, num_tool_calls
active_lock = conn.execute(
"SELECT holder FROM compression_locks "
"WHERE session_id = ? AND expires_at > ?",
(session_id, time.time()),
).fetchone()
if (
active_lock is not None
and active_lock["holder"] != compression_lock_holder
):
raise SessionCompressionInProgressError(
f"Session {session_id!r} is being compressed by another writer"
)
session = conn.execute(
"SELECT ended_at, end_reason FROM sessions WHERE id = ?",
(session_id,),
).fetchone()
if (
session is not None
and session["ended_at"] is not None
and session["end_reason"] == "compression"
):
raise CompressionSessionClosedError(session_id)
@staticmethod
def _decode_display_metadata(raw: Any) -> Optional[Dict[str, Any]]:
@@ -6179,53 +6101,84 @@ class SessionDB(SessionSearchMixin, SessionSchemaMixin, SessionPortabilityMixin)
from every outgoing payload anyway, so the scrubbed form IS the
wire bytes).
"""
row_params, num_tool_calls = self._prepare_message_row(
session_id=session_id,
role=role,
content=content,
tool_name=tool_name,
tool_calls=tool_calls,
tool_call_id=tool_call_id,
token_count=token_count,
finish_reason=finish_reason,
reasoning=reasoning,
reasoning_content=reasoning_content,
reasoning_details=reasoning_details,
codex_reasoning_items=codex_reasoning_items,
codex_message_items=codex_message_items,
platform_message_id=platform_message_id,
observed=observed,
effect_disposition=effect_disposition,
timestamp=timestamp,
api_content=api_content,
display_kind=display_kind,
display_metadata=display_metadata,
# Display metadata is presentation-only and never changes the model
# context role/content replayed to providers.
display_metadata_json = self._encode_display_metadata(display_metadata)
# Serialize structured fields to JSON before entering the write txn
reasoning_details_json = (
json.dumps(reasoning_details)
if reasoning_details else None
)
codex_items_json = (
json.dumps(codex_reasoning_items)
if codex_reasoning_items else None
)
codex_message_items_json = (
json.dumps(codex_message_items)
if codex_message_items else None
)
# tool_calls may arrive as a Python list (from the live agent) or
# as a JSON string (from import/export). Parse first to avoid
# double-encoding.
if isinstance(tool_calls, str):
try:
tool_calls = json.loads(tool_calls)
except (json.JSONDecodeError, TypeError):
tool_calls = []
tool_calls_json = json.dumps(tool_calls) if tool_calls else None
# Multimodal content (list of parts) must be JSON-encoded: sqlite3
# cannot bind list/dict parameters directly.
stored_content = self._encode_content(content)
message_timestamp = time.time()
if timestamp is not None:
try:
if hasattr(timestamp, "timestamp"):
message_timestamp = float(timestamp.timestamp())
else:
message_timestamp = float(timestamp)
except (TypeError, ValueError):
logger.debug("Ignoring invalid explicit message timestamp: %r", timestamp)
# Pre-compute tool call count
num_tool_calls = 0
if tool_calls is not None:
num_tool_calls = len(tool_calls) if isinstance(tool_calls, list) else 1
def _do(conn):
active_lock = conn.execute(
"SELECT holder FROM compression_locks "
"WHERE session_id = ? AND expires_at > ?",
(session_id, time.time()),
).fetchone()
if (
active_lock is not None
and active_lock["holder"] != compression_lock_holder
):
raise SessionCompressionInProgressError(
f"Session {session_id!r} is being compressed by another writer"
)
session = conn.execute(
"SELECT ended_at, end_reason FROM sessions WHERE id = ?",
(session_id,),
).fetchone()
if (
session is not None
and session["ended_at"] is not None
and session["end_reason"] == "compression"
):
raise CompressionSessionClosedError(session_id)
cursor = conn.execute(self._MESSAGE_INSERT_SQL, row_params)
self._check_transcript_write_guards(
conn, session_id, compression_lock_holder
)
cursor = conn.execute(
"""INSERT INTO messages (session_id, role, content, tool_call_id,
tool_calls, tool_name, effect_disposition, timestamp, token_count, finish_reason,
reasoning, reasoning_content, reasoning_details, codex_reasoning_items,
codex_message_items, platform_message_id, observed, active, api_content, display_kind, display_metadata)
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)""",
(
session_id,
role,
stored_content,
tool_call_id,
tool_calls_json,
_scrub_surrogates(tool_name),
effect_disposition,
message_timestamp,
token_count,
finish_reason,
_scrub_surrogates(reasoning),
_scrub_surrogates(reasoning_content),
reasoning_details_json,
codex_items_json,
codex_message_items_json,
platform_message_id,
1 if observed else 0,
1,
_scrub_surrogates(api_content) if isinstance(api_content, str) else None,
_scrub_surrogates(display_kind) if isinstance(display_kind, str) else None,
display_metadata_json,
),
)
msg_id = cursor.lastrowid
# Update counters
@@ -6256,102 +6209,68 @@ class SessionDB(SessionSearchMixin, SessionSchemaMixin, SessionPortabilityMixin)
session_id: str,
messages: List[Dict[str, Any]],
compression_lock_holder: Optional[str] = None,
) -> List[int]:
chunk_rows: Optional[int] = None,
) -> int:
"""Append multiple messages atomically in ONE write transaction.
``messages`` is a list of dicts whose keys mirror
:meth:`append_message`'s keyword arguments (role, content, tool_name,
tool_calls, tool_call_id, finish_reason, reasoning, reasoning_content,
reasoning_details, codex_reasoning_items, codex_message_items,
timestamp, api_content, display_kind, display_metadata, ...).
``messages`` is a list of dicts in the same shape
:meth:`_insert_message_rows` already consumes for replace/compact/
import (role, content, tool_name, tool_calls, tool_call_id,
finish_reason, reasoning*, codex_*, timestamp, api_content,
display_kind, display_metadata, ...). Reusing that helper keeps ONE
row-serialization path for every multi-row writer.
A turn-boundary flush writes the whole turn (user + assistant + tool
rows, typically 3-8 messages) as one BEGIN IMMEDIATE / commit pair
instead of one transaction (and, off WAL, one fsync) per row. Row
serialization happens OUTSIDE the transaction via
``_prepare_message_row`` — the same helper ``append_message`` uses,
so the row shape cannot drift between the two writers.
instead of one transaction (and, off WAL, one fsync) per row.
Atomicity contract: all rows land or none do (the caller re-flushes
unstamped messages on the next attempt). The compression-lock and
compression-closed guards from ``append_message`` run once for the
batch — same session, same instant. Returns the inserted row IDs in
input order.
unstamped messages on the next attempt). The same admission guards
as :meth:`append_message` run once for the batch — same session,
same instant.
``chunk_rows`` bounds the transaction size for LARGE copies (branch
seeds can be thousands of rows; measured: 10k rows ≈ 2.4s inside one
BEGIN IMMEDIATE because the FTS triggers run per row, which would
monopolize the write lock and starve concurrent writers). When set,
the batch commits in chunks of at most that many rows — same
recovery semantics as the old per-row loops (a mid-copy failure
leaves a partial seed), just with bounded lock holds. A turn flush
never needs it. Returns the inserted row count.
"""
if not messages:
return []
return 0
prepared: List[tuple] = []
total_tool_calls = 0
for msg in messages:
role = msg.get("role", "unknown")
params, num_tc = self._prepare_message_row(
session_id=session_id,
role=role,
content=msg.get("content"),
tool_name=msg.get("tool_name"),
tool_calls=msg.get("tool_calls"),
tool_call_id=msg.get("tool_call_id"),
token_count=msg.get("token_count"),
finish_reason=msg.get("finish_reason"),
reasoning=msg.get("reasoning") if role == "assistant" else None,
reasoning_content=msg.get("reasoning_content") if role == "assistant" else None,
reasoning_details=msg.get("reasoning_details") if role == "assistant" else None,
codex_reasoning_items=msg.get("codex_reasoning_items") if role == "assistant" else None,
codex_message_items=msg.get("codex_message_items") if role == "assistant" else None,
platform_message_id=msg.get("platform_message_id"),
observed=bool(msg.get("observed")),
effect_disposition=msg.get("effect_disposition"),
timestamp=msg.get("timestamp"),
api_content=msg.get("api_content"),
display_kind=msg.get("display_kind"),
display_metadata=msg.get("display_metadata"),
)
prepared.append(params)
total_tool_calls += num_tc
if chunk_rows is not None and len(messages) > chunk_rows:
inserted_total = 0
for start in range(0, len(messages), chunk_rows):
inserted_total += self.append_messages_batch(
session_id,
messages[start:start + chunk_rows],
compression_lock_holder=compression_lock_holder,
)
return inserted_total
def _do(conn):
active_lock = conn.execute(
"SELECT holder FROM compression_locks "
"WHERE session_id = ? AND expires_at > ?",
(session_id, time.time()),
).fetchone()
if (
active_lock is not None
and active_lock["holder"] != compression_lock_holder
):
raise SessionCompressionInProgressError(
f"Session {session_id!r} is being compressed by another writer"
)
session = conn.execute(
"SELECT ended_at, end_reason FROM sessions WHERE id = ?",
(session_id,),
).fetchone()
if (
session is not None
and session["ended_at"] is not None
and session["end_reason"] == "compression"
):
raise CompressionSessionClosedError(session_id)
row_ids: List[int] = []
for params in prepared:
cursor = conn.execute(self._MESSAGE_INSERT_SQL, params)
row_ids.append(cursor.lastrowid)
self._check_transcript_write_guards(
conn, session_id, compression_lock_holder
)
inserted, tool_calls_total = self._insert_message_rows(
conn, session_id, messages
)
# One aggregated counter update for the whole batch.
if total_tool_calls > 0:
if tool_calls_total > 0:
conn.execute(
"""UPDATE sessions SET message_count = message_count + ?,
tool_call_count = tool_call_count + ? WHERE id = ?""",
(len(prepared), total_tool_calls, session_id),
(inserted, tool_calls_total, session_id),
)
else:
conn.execute(
"UPDATE sessions SET message_count = message_count + ? WHERE id = ?",
(len(prepared), session_id),
(inserted, session_id),
)
return row_ids
return inserted
# Same criticality as append_message: this IS the turn's transcript.
return self._execute_write(
+7 -5
View File
@@ -2225,11 +2225,13 @@ class AIAgent:
"tool_calls": tool_calls_data,
"tool_call_id": msg.get("tool_call_id"),
"finish_reason": msg.get("finish_reason"),
"reasoning": msg.get("reasoning") if role == "assistant" else None,
"reasoning_content": msg.get("reasoning_content") if role == "assistant" else None,
"reasoning_details": msg.get("reasoning_details") if role == "assistant" else None,
"codex_reasoning_items": msg.get("codex_reasoning_items") if role == "assistant" else None,
"codex_message_items": msg.get("codex_message_items") if role == "assistant" else None,
# Reasoning/codex fields are role-gated (assistant-only)
# inside _insert_message_rows — pass through untouched.
"reasoning": msg.get("reasoning"),
"reasoning_content": msg.get("reasoning_content"),
"reasoning_details": msg.get("reasoning_details"),
"codex_reasoning_items": msg.get("codex_reasoning_items"),
"codex_message_items": msg.get("codex_message_items"),
"timestamp": _row_timestamp,
"api_content": _row_api_content,
"display_kind": (
@@ -1,8 +1,9 @@
"""Tests for SessionDB.append_messages_batch (#23254 salvage).
The batch writer must be row-shape-identical to append_message (shared
_prepare_message_row + _MESSAGE_INSERT_SQL), atomic (all rows or none),
and must aggregate the session counters in one UPDATE.
The batch writer reuses _insert_message_rows (the same row-serialization
path as replace/compact/import), runs the same admission guards as
append_message, is atomic (all rows or none), and aggregates the session
counters in one UPDATE.
"""
import json
@@ -80,6 +81,26 @@ class TestAppendMessagesBatch:
finally:
db2.close()
def test_reasoning_gated_to_assistant_rows(self, db):
"""_insert_message_rows role-gates reasoning fields; a tool row
carrying reasoning keys must not persist them."""
db.append_messages_batch(
"sess-batch",
[
{
"role": "tool",
"content": "out",
"tool_name": "t",
"tool_call_id": "c1",
"reasoning_content": "should not persist",
}
],
)
row = db._conn.execute(
"SELECT reasoning_content FROM messages"
).fetchone()
assert row[0] is None
def test_counters_aggregate_once(self, db):
db.append_messages_batch("sess-batch", _turn_messages())
row = db._conn.execute(
@@ -89,13 +110,11 @@ class TestAppendMessagesBatch:
assert row["message_count"] == 4
assert row["tool_call_count"] == 1
def test_returns_row_ids_in_input_order(self, db):
ids = db.append_messages_batch("sess-batch", _turn_messages())
assert ids == sorted(ids)
assert len(ids) == 4
def test_returns_inserted_count(self, db):
assert db.append_messages_batch("sess-batch", _turn_messages()) == 4
def test_empty_batch_is_noop(self, db):
assert db.append_messages_batch("sess-batch", []) == []
assert db.append_messages_batch("sess-batch", []) == 0
row = db._conn.execute(
"SELECT message_count FROM sessions WHERE id = ?", ("sess-batch",)
).fetchone()
@@ -103,31 +122,26 @@ class TestAppendMessagesBatch:
def test_atomicity_all_or_nothing(self, db, monkeypatch):
"""A failure mid-batch leaves ZERO rows and untouched counters."""
real_execute_write = db._execute_write
original_insert = SessionDB._MESSAGE_INSERT_SQL
real_insert = SessionDB._insert_message_rows
calls = {"n": 0}
def failing_insert(self_db, conn, session_id, messages):
real_conn_execute = conn.execute
calls = {"n": 0}
def _do_wrapper(fn, **kwargs):
def failing(conn):
real_conn_execute = conn.execute
def exec_counting(sql, *args):
if sql.lstrip().startswith("INSERT INTO messages"):
calls["n"] += 1
if calls["n"] == 3:
raise sqlite3.OperationalError("boom mid-batch")
return real_conn_execute(sql, *args)
def exec_counting(sql, *args):
if sql == original_insert:
calls["n"] += 1
if calls["n"] == 3:
raise sqlite3.OperationalError("boom mid-batch")
return real_conn_execute(sql, *args)
conn.execute = exec_counting
try:
return real_insert(self_db, conn, session_id, messages)
finally:
conn.execute = real_conn_execute
conn.execute = exec_counting
try:
return fn(conn)
finally:
conn.execute = real_conn_execute
return real_execute_write(failing, **kwargs)
monkeypatch.setattr(db, "_execute_write", _do_wrapper)
monkeypatch.setattr(SessionDB, "_insert_message_rows", failing_insert)
with pytest.raises(sqlite3.OperationalError):
db.append_messages_batch("sess-batch", _turn_messages())
monkeypatch.undo()
+4 -3
View File
@@ -2649,9 +2649,9 @@ def _(rid, params: dict) -> dict:
else None
),
)
# Copy the whole parent history in ONE transaction — a branch
# seed can be hundreds of rows, and per-row transactions were
# the write-amplification pattern removed in #23254.
# Copy the whole parent history in bounded-chunk transactions —
# a branch seed can be hundreds of rows, and per-row transactions
# were the write-amplification pattern removed in #23254.
db.append_messages_batch(
new_key,
[
@@ -2664,6 +2664,7 @@ def _(rid, params: dict) -> dict:
}
for msg in history
],
chunk_rows=500,
)
db.set_session_title(new_key, title)
except Exception as e:
+6 -3
View File
@@ -2749,9 +2749,11 @@ def _persist_branch_seed(session: dict) -> None:
if db is None:
return
try:
# One transaction for the whole seed (see #23254): a branch seed
# can be hundreds of rows and is all-or-nothing anyway — the
# _branch_seed_persisted flag below assumes every row landed.
# Bounded-chunk transactions (see #23254): a branch seed can be
# hundreds of rows; chunking keeps each BEGIN IMMEDIATE short so
# concurrent writers aren't starved. Recovery semantics match the
# old per-row loop (mid-copy failure leaves a partial seed with
# _branch_seed_persisted unset).
db.append_messages_batch(
key,
[
@@ -2765,6 +2767,7 @@ def _persist_branch_seed(session: dict) -> None:
}
for msg in seed
],
chunk_rows=500,
)
session["_branch_seed_persisted"] = True
except Exception as exc: