[lesomnus]

Two holes in how a transaction begun with dialect.BeginTx is ended, found in the review of lesomnus/payday#84's work (T5-4, T5-5).

1. BeginTx inside a transaction it did not begin

BeginTx nested only when KeepOf recognised the transaction drv runs in. Inside one it could not recognise — a generated client's Client.Tx, whose driver says it is a transaction (InTx) and keeps nothing — it began a second Keep over the no-op transaction that driver hands out. That keep answered to the wrong end:

• its commit wrote what it kept into a transaction it did not end;
• its rollback dropped what it kept, while the writes it was about stayed for whoever ended the transaction.

What a transaction keeps is what makes the rest of it acceptable. In lesomnus/payday that is the trail, so a write committed this way is a write the record does not have. Nothing reaches this today; every stack is rebound onto a BeginTx driver.

Now:

• BeginTx refuses with ErrForeignTx and begins nothing when the driver is in a transaction (InTx) that keeps nothing (KeepOf). It looks through a DebugDriver, as both of those do.
• What BeginTx hands its caller is a driver.Tx: Commit and Rollback, nothing else. It was a dialect.Tx, which can also send statements — straight to the connection, past the driver that asks the keep about each one (Keep.BeforeStatement). A transaction begun inside another hands back an end that does nothing, as before.

Callers that only Commit and Rollback what they are handed compile unchanged. In payday that is the generated batch, rove and roster. One payday test helper is typed dialect.Tx and changes with payday's bump.

2. Work that failed partway in a transaction it joined

A generated write joins a transaction it finds itself in rather than nesting one; there are no savepoints. Its Close does nothing there, since ending that transaction is not its job. So when the write failed after it had begun writing, what it wrote stayed in the transaction:

• PostgreSQL takes the whole transaction with a failed statement.
• SQLite undoes the statement alone.
• A failure that was not a statement's — a recorder, a read after the write — undoes nothing on either engine.

A caller that went on and committed would commit part of a write it had been told had failed. The case that showed it is an AddMany whose second INSERT of a few hundred rows is refused.

Now:

• Keep.Refuse(err) says a transaction may not commit. Its commit answers err and rolls back, and the kept work is not done. The first refusal is the one answered.
• ent.Joined says it for the work:
  • When JoinTx joins a transaction BeginTx began, it holds that transaction's keep.
  • The work calls Writing() before its first statement that writes.
  • A Close with no Commit after that refuses the joined transaction's commit with ErrPartial.
• What does not refuse:
  • Work that fails before it writes has nothing to take back, and refuses nothing.
  • Work that began its own transaction is taken back by its Close, as before.
  • A transaction that keeps nothing (a generated Client.Tx) is its owner's to answer for.
• ent.Db asks for the client's Driver(), which is where the keep is found. A generated client has always had it.

protoc-gen-orm-ent will emit tx.Writing() in each generated write, in a PR that follows this one.

UPSTREAM.md's Transactions row says all of this.

Tests

Each test fails with its line taken out (mutations listed after each group).

• dialect, on the doubles:

  • BeginTx on a foreign transaction is refused, as it is and under a DebugDriver, and begins nothing.
  • Neither end it hands back, begun or begun inside, can send a statement.
  • A refusal is the commit's, and the kept work is not done.
  • The first refusal is the one answered, and nil refuses nothing.
  • A refusal said while the kept work runs, or said inside a transaction begun inside, is the commit's.

  Mutations: no ErrForeignTx check; the nested end being the inner transaction; finish not reading the refusal; finish reading it only before the work.

• root (Joined), on the doubles:

  • A joined write that began writing and failed refuses the commit (ErrPartial).
  • One that failed before writing does not, and neither does one that held.
  • One that wanted no transaction is told the same.
  • One in a transaction that keeps nothing tells nobody.
  • One that began its own transaction rolls back.

  Mutations: Close not refusing; Writing not marking; Commit not marking.

• entc/integration/keep, on every engine: a refused transaction takes its writes back.

• entc/integration/stduuid, on a generated client:

  • A joined write that failed partway leaves nothing committed.
  • BeginTx on a Client.Tx's driver is refused.

• Locally:

  • go test ./ ./dialect/....
  • entc/integration keep (SQLite) and stduuid.
  • go build ./... in the root, examples and entc/integration.
  • .github/lint.sh on the changed files.

  CI runs the other engines.

🤖 Generated with Claude Code

https://claude.ai/code/session_01KxtnpRW533bdErnW8QPhsk