beads/internal/storage/sqlcount/sqlcount.go
Julian Knutsen 6cd1184687
feat(httpapi): opt-in large issues:batchApply envelope (≤1000 items, one transaction) (#7051)
* test(storage): measure ApplyBatchInTx SQL statement counts (B0)

Adds a driver.Connector-level counting/latency-injecting wrapper
(internal/storage/sqlcount) plus shared plan-request fixtures
(internal/storage/batchfixtures: mol-normalized 356/712-item shapes and a
40-item classic shape) and backend-specific pinning tests + benchmarks
(internal/storage/embeddeddolt, internal/storage/dolt) that measure the
ACTUAL number of SQL statements issueops.ApplyBatchInTx issues for each
shape, on both the embedded and Dolt (TCP) backends.

Measured totals (Prepare+Exec+Query+StmtExec+StmtQuery inside one
transaction): 356 items ~7008-7009, 712 items 14014-14015, 40 items 846,
identical on both backends (expected: statement issuance is driven by Go
application logic, not backend-specific SQL planning). Pinned with a small
(+/-2) tolerance to absorb an observed, host-contention-driven +/-1 Query
drift (Exec is deterministic on every run). This is the regression baseline
slice B2 (a later, lighter fast path) must demonstrably lower.

batchfixtures.UncappedPlan bypasses issueops.MaxApplyBatchItems so this
measurement does not depend on slice B1's cap raise.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

* feat(httpapi,issueops): raise batchApply envelope to 1000 items with bounded large-apply handling

POST /v0/beads/issues:batchApply now accepts up to 1000 items (up from 100);
issueops.MaxApplyBatchItems moves accordingly and the request body cap rises
to 16 MiB. The whole plan still applies in exactly ONE transaction. A request
over 100 items runs under a separate, flat, operator-configured whole-run
budget (`bd serve --large-apply-ceiling`, 5 minutes by default) instead of
the ordinary 60s request deadline; a request at or under 100 items is
unaffected and keeps exactly the 60s deadline and 15s commit-retry ceiling it
always had.

Concurrency and shutdown are bounded, not just documented:
- Oversized requests serialize through a dedicated one-wide semaphore, and at
  most one caller may wait for that semaphore at a time (a CAS-guarded single
  waiter) — a burst of oversized requests is shed with 503 rather than
  queuing and starving ordinary traffic behind the general semaphore.
- The run deadline is stamped only once the slot is actually acquired, not
  at the time the request arrived.
- Graceful shutdown closes new admissions before computing its drain budget,
  then waits out an in-flight large apply up to its own remaining deadline
  (plus a few seconds' grace for the response to write); any large apply
  still queued for the semaphore when shutdown begins is refused rather than
  extending the drain further. A queued caller that disconnects gets a clean
  503, never a misclassified context error. `bd serve`'s orchestrator stop
  grace must be at least `--large-apply-ceiling` — see
  engdocs/SERVE_RUNBOOK.md.
- ApplyBatch's commit-retry budget only extends past the ordinary 15s ceiling
  on this explicit large-apply path (via a context marker), with headroom
  reserved so the final retry attempt can't be killed mid-commit by the
  context's own expiry.

A new `issues.batchApplyLarge` capability token on `GET /v0/beads/context`
lets a client learn whether a given server accepts the raised envelope.

Wall-clock measurement (embedded Dolt, whole-transaction build+commit) backs
the 5-minute ceiling default: 356 items ~12.6s (23.8x headroom), 1000 items
~57.5s (5.2x headroom).

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

* fix(httpapi,serve): wire the large-apply retry budget; repair stale pins

Review fixes for the large batchApply envelope, on top of the test
repairs the PR needed against main.

The extended commit-retry budget was never switched on.
internal/storage/uow's retryTxBudget lets a large apply keep retrying a
commit-time conflict past the ordinary 15s ceiling only when its context
carries issueops.WithExtendedRetryBudget's marker, and the docs on both
sides say admitLargeApply sets it, but nothing did: the marker's only
callers were the uow tests, which mark their contexts by hand. A
1000-item apply that hit a conflict still gave up after 15s with most of
its 5-minute ceiling unused. admitLargeApply now marks the run context
it builds, and TestApplyBatchMarksOnlyALargeApplyForTheExtendedRetryBudget
pins the seam over HTTP: marked at 101 and 1000 items, unmarked at 100.
Removing the mark fails the 101 and 1000 cases; marking every request in
handleApplyBatch fails the 100 case.

Smaller fixes from the same review:

- `bd serve --large-apply-ceiling` repeated the 5m default as a literal
  of its own, and since bd serve always passes a positive ceiling, that
  literal, not httpapi's, was the default every deployment ran. Export
  httpapi.DefaultLargeApplyCeiling, default the flag to it, and pin the
  flag's 5m0s default in TestServeFlags.
- admitLargeApply's release cancels the run context before clearing
  s.largeApplyDeadline, the order acquireLargeApply's doc states; it
  cleared the deadline first.
- Drop the batchfixtures test's dead t.Skipf, which waited for the cap
  to reach 1000, and correct a graph-counter comment that still cited
  the 100-item cap and the TestServeFlags doc line that called the
  no-argument server unchanged.

The PR raises issueops.MaxApplyBatchItems from 100 to 1000 and adds
`bd serve --large-apply-ceiling`, but two base-owned tests still pinned
the old surface and went red on every lane that runs them (Bazel / test,
Test (macos-latest)):

- TestServeFlags pins the exact `bd serve` flag list; add
  large-apply-ceiling.
- TestPlanApplyBatchRefusesAnUnusableRequest/too_many_items built 101
  items and expected "at most 100 items", a request the 1000 cap now
  plans successfully. Size the over-cap request and its message from
  issueops.MaxApplyBatchItems, as TestPlanApplyBatchAcceptsTheBoundary
  already does for the other side of the cap; the cap's value stays
  pinned by TestCapBatchApplyLargeTiesAllThreeLimits.

The PR's own TestLargeApplyBurstNeverStarvesSmallRequestsForSemTimeout
also went red in PR Core (-race, -p 4 on a 4-vCPU runner): all eight
small requests took 160-165ms against a 100ms bound. The stall it
guards against lasts semTimeout (5s), while a small request can still
queue briefly behind the refused large requests, each holding a general
sem slot while its body decodes. Bound it at a second, the "want well
under a second" its sibling TestLargeApplyQueueDoesNotStarveOrdinaryRequests
already uses. Pinned to four cores beside 24 busy loops, small requests
measured 183ms mean and 338ms max, and the 1s bound passed 80/80 runs;
with the one-waiter gate in acquireLargeApply disabled the test still
fails 3/3, on its 2s never-completed check.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(uow): stop a doomed large-apply retry before ctx cuts it off

retryTxBudget sizes maxElapsed once at ApplyBatch entry, but says nothing
about how long an individual attempt takes. A slow first attempt (e.g.
157s of a large apply's commit) left little of the budget for a retry,
which then got killed mid-transaction by ctx's own deadline instead of
finishing and reporting its own outcome -- surfacing as
context.DeadlineExceeded (isUnavailable excludes it -> a generic 500)
instead of the exhausted-write-conflict result this loop already reports
correctly (-> 503 + Retry-After).

RunTxResultWithin now tracks the previous attempt's duration and, before
starting a new one, stops early with the last real serialization error
when time left on ctx is less than that duration plus a fixed headroom --
but only when publicops.HasExtendedRetryBudget(ctx) is set (the same
marker retryTxBudget itself checks). Applying the look-ahead
unconditionally regressed TestApplyBatchHonorsAnExtendedRetryBudgetFromContext's
unmarked case: ordinary requests have cheap attempts and are meant to run
until their own ctx deadline ends the loop, and the large-apply-sized 5s
headroom was tripping that for any short-ctx caller with a near-instant
failing attempt.

Adds TestRunTxResultWithin_SlowAttemptStopsBeforeADoomedRetry (a 1.2s
commit against a 2s marked ctx must stop after one attempt with its own
serialization error, never DeadlineExceeded, and never touch a second
unit of work) and its control, TestRunTxResultWithin_ShortAttemptStillRetries
(a 50ms attempt against the same shape must still retry and succeed).
Both mutation-checked against the look-ahead condition and its gate.

Also updates the stale "items accepts at most 100 entries" prose on the
applyBatch endpoint description (openapi.v0.yaml) to the large-envelope
wording already used elsewhere in the spec: 1000-item cap behind the
issues.batchApplyLarge capability, large-apply-ceiling deadline extension,
<=100 unaffected. dependencies:count's own "at most 100" lines are
unrelated and untouched.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

* fix(ci,serve): fit the 1000-item cap's tests in the storage shard budget

Review fixes for the relaunched #7051, iteration 1.

Raising issueops.MaxApplyBatchItems from 100 to 1000 made the base-owned
TestBatchApplyContract take 604s under -race, against 97s at the old cap
(main run 35862663577). It hashed onto the legacy test-embedded-storage
shard 2/5, beside ~5m of other tests, and that shard hit its 15m budget
twice (PR Risk run 36807191489). PR Risk no longer runs the legacy tier
on same-repo PRs (#7071), but Main's push run and fork PRs still do, so
the merge would have carried the timeout to Main.

Raising the jobs' timeout-minutes alone would not fix it: the shard
script passes the binary its own -test.timeout=15m. So:

- embedded-storage-test-shard.sh passes -test.timeout=20m (and its go
  test fallback -timeout 20m), as embedded-test-shard.sh does for
  cmd/bd.
- test-embedded-storage in main.yml and pr-risk.yml: timeout-minutes 15
  -> 25, the script's 20m plus setup.
- embeddeddolt_embedded_test appends -test.timeout=19m, as
  bd_embedded_test does, so Go's timeout, which dumps every goroutine,
  fires before rbe-west's 1200s action kill, which does not.
  TestBazelEmbeddedJobMirrorsEmbeddedTier now checks the override on
  both sharded targets instead of only cmd/bd's, and the PR Risk
  coverage test pins the storage target's new args.
- embedded-storage-test-shards.txt places TestBatchApplyContract on
  shard 4, which has ~3m of other tests, and the PR's two large-batch
  tests, TestLargeBatchApplyStatementCounts_Embedded (247s) and
  TestLargeBatchApplyWallClock_Embedded (261s), on shards 2 and 5. From
  the PR run's per-test times, the heaviest shard projects to ~13m, down
  from shard 2's 15m-plus.

Also correct the stop-grace guidance. For an in-flight large apply,
Serve's drain waits out the apply's remaining deadline plus drainGrace
(5s), so the orchestrator's stop grace must be at least
--large-apply-ceiling plus 5s, as Serve's own doc says. The runbook, the
flag help, the LargeApplyCeiling field doc and the CHANGELOG entry asked
for the ceiling alone.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

---------

Co-authored-by: Gas City Adopt-PR <adopt-pr@gascity.local>
Co-authored-by: Claude Sonnet 5 <noreply@anthropic.com>
2026-10-01 08:32:56 -07:00

417 lines
14 KiB
Go

// Package sqlcount wraps a database/sql/driver.Connector so a test or
// benchmark can count how many SQL statements a code path actually issues
// against a real driver, and optionally inject artificial per-statement
// latency to approximate a database that is not co-located with the caller.
//
// It exists for the large-batch-apply measurement work: issueops.ApplyBatchInTx
// takes a concrete *sql.Tx, not an interface, so the only seam available to
// count its real round trips is the database/sql/driver boundary itself. Wrapping the
// driver.Connector a backend already builds — mysql.NewConnector for the Dolt
// server backend, doltembed.NewConnector for the embedded backend — is the
// one construction point both backends share, so one wrapper measures both
// without touching either driver or any production code path.
package sqlcount
import (
"context"
"database/sql/driver"
"fmt"
"sync/atomic"
"time"
)
// Counts tracks how many times each driver entry point that represents one
// SQL statement or round trip fired. The zero value is ready to use. Safe
// for concurrent use.
type Counts struct {
prepare int64
exec int64
query int64
stmtExec int64
stmtQuery int64
begin int64
commit int64
rollback int64
}
// Snapshot is a point-in-time, plain copy of Counts, safe to diff, log or
// assert on without synchronization.
type Snapshot struct {
Prepare int64
Exec int64
Query int64
StmtExec int64
StmtQuery int64
Begin int64
Commit int64
Rollback int64
}
// Total is every round trip this wrapper attributes to an executed SQL
// statement: a Prepare, a driver-level Exec/Query issued without a separate
// prepare, or an Exec/Query against an already-prepared statement. Begin,
// Commit and Rollback are reported on Snapshot but excluded here, because a
// caller measuring one transaction's BODY (issueops.ApplyBatchInTx, for
// instance) opens and closes that transaction outside the measured window.
func (s Snapshot) Total() int64 {
return s.Prepare + s.Exec + s.Query + s.StmtExec + s.StmtQuery
}
// Sub returns the per-field difference s-prior, for isolating one call's
// contribution on a longer-lived connection.
func (s Snapshot) Sub(prior Snapshot) Snapshot {
return Snapshot{
Prepare: s.Prepare - prior.Prepare,
Exec: s.Exec - prior.Exec,
Query: s.Query - prior.Query,
StmtExec: s.StmtExec - prior.StmtExec,
StmtQuery: s.StmtQuery - prior.StmtQuery,
Begin: s.Begin - prior.Begin,
Commit: s.Commit - prior.Commit,
Rollback: s.Rollback - prior.Rollback,
}
}
// Snapshot reads every counter. The read is not atomic ACROSS fields — a
// concurrent writer could interleave between two loads — which matches every
// other multi-atomic snapshot in this tree taken for one log line or report.
func (c *Counts) Snapshot() Snapshot {
return Snapshot{
Prepare: atomic.LoadInt64(&c.prepare),
Exec: atomic.LoadInt64(&c.exec),
Query: atomic.LoadInt64(&c.query),
StmtExec: atomic.LoadInt64(&c.stmtExec),
StmtQuery: atomic.LoadInt64(&c.stmtQuery),
Begin: atomic.LoadInt64(&c.begin),
Commit: atomic.LoadInt64(&c.commit),
Rollback: atomic.LoadInt64(&c.rollback),
}
}
// Reset zeroes every counter, for reuse across benchmark iterations.
func (c *Counts) Reset() {
atomic.StoreInt64(&c.prepare, 0)
atomic.StoreInt64(&c.exec, 0)
atomic.StoreInt64(&c.query, 0)
atomic.StoreInt64(&c.stmtExec, 0)
atomic.StoreInt64(&c.stmtQuery, 0)
atomic.StoreInt64(&c.begin, 0)
atomic.StoreInt64(&c.commit, 0)
atomic.StoreInt64(&c.rollback, 0)
}
// Total is c.Snapshot().Total(), for a caller that wants one number without
// composing the two calls.
func (c *Counts) Total() int64 { return c.Snapshot().Total() }
// options carries WrapConnector's optional behavior.
type options struct {
latency time.Duration
}
// Option configures WrapConnector.
type Option func(*options)
// WithLatency injects a sleep before every counted round trip — Prepare,
// Exec, Query, a prepared statement's Exec/Query, Begin, Commit and Rollback
// alike — so a co-located backend can approximate the wall-clock cost of a
// database that is NOT co-located with the caller. It respects the caller's
// context: a canceled or expired context aborts the sleep and returns the
// context's error rather than padding out a call that is already doomed.
func WithLatency(d time.Duration) Option {
return func(o *options) { o.latency = d }
}
// WrapConnector wraps inner so every statement-shaped call on the
// connections it hands out increments counts, and optionally sleeps first.
// inner is the driver.Connector a backend already constructs
// (mysql.NewConnector for the Dolt server backend, doltembed.NewConnector
// for the embedded backend); wrapping it rather than registering a new
// driver under a new name is what lets a test open a SECOND, counted
// connection against the SAME already-migrated embedded directory or the
// SAME live Dolt server a backend's own store already opened, so the
// production open/migrate path never has to know this wrapper exists.
func WrapConnector(inner driver.Connector, counts *Counts, opts ...Option) driver.Connector {
o := &options{}
for _, opt := range opts {
opt(o)
}
return &wrappedConnector{inner: inner, counts: counts, opts: o}
}
type wrappedConnector struct {
inner driver.Connector
counts *Counts
opts *options
}
func (c *wrappedConnector) Connect(ctx context.Context) (driver.Conn, error) {
inner, err := c.inner.Connect(ctx)
if err != nil {
return nil, err
}
return &wrappedConn{inner: inner, counts: c.counts, opts: c.opts}, nil
}
func (c *wrappedConnector) Driver() driver.Driver {
return &wrappedDriver{inner: c.inner.Driver(), counts: c.counts, opts: c.opts}
}
// wrappedDriver exists only to satisfy driver.Connector.Driver's return
// type. database/sql calls Driver() for error classification and
// sql.DB.Driver(); this wrapper never uses it to open a second connection
// outside wrappedConnector.Connect.
type wrappedDriver struct {
inner driver.Driver
counts *Counts
opts *options
}
func (d *wrappedDriver) Open(name string) (driver.Conn, error) {
inner, err := d.inner.Open(name)
if err != nil {
return nil, err
}
return &wrappedConn{inner: inner, counts: d.counts, opts: d.opts}, nil
}
// sleep injects the configured latency, honoring ctx cancellation.
func (o *options) sleep(ctx context.Context) error {
if o.latency <= 0 {
return nil
}
t := time.NewTimer(o.latency)
defer t.Stop()
select {
case <-t.C:
return nil
case <-ctx.Done():
return ctx.Err()
}
}
// wrappedConn wraps a driver.Conn. It implements every optional modern
// interface (ExecerContext, QueryerContext, ConnPrepareContext,
// ConnBeginTx, Pinger, SessionResetter, Validator, NamedValueChecker),
// delegating to the inner connection's implementation when present and
// falling back to the legacy path — or driver.ErrSkip — when not, so
// database/sql's behavior with the wrapper in place matches its behavior
// with the inner driver alone.
//
// NamedValueChecker is always implemented (never omitted) because
// database/sql decides parameter-conversion behavior by checking interface
// satisfaction on the WRAPPER's concrete type, not the inner driver's:
// omitting it here would silently change conversion behavior relative to
// running against the inner driver directly, regardless of what the inner
// driver itself implements.
type wrappedConn struct {
inner driver.Conn
counts *Counts
opts *options
}
func (c *wrappedConn) Prepare(query string) (driver.Stmt, error) {
atomic.AddInt64(&c.counts.prepare, 1)
inner, err := c.inner.Prepare(query)
if err != nil {
return nil, err
}
return &wrappedStmt{inner: inner, counts: c.counts, opts: c.opts}, nil
}
func (c *wrappedConn) Close() error { return c.inner.Close() }
//nolint:staticcheck // legacy driver.Conn.Begin, required by the interface; BeginTx below is preferred when available.
func (c *wrappedConn) Begin() (driver.Tx, error) {
atomic.AddInt64(&c.counts.begin, 1)
inner, err := c.inner.Begin() //nolint:staticcheck
if err != nil {
return nil, err
}
return &wrappedTx{inner: inner, counts: c.counts}, nil
}
func (c *wrappedConn) PrepareContext(ctx context.Context, query string) (driver.Stmt, error) {
pc, ok := c.inner.(driver.ConnPrepareContext)
if !ok {
return c.Prepare(query)
}
if err := c.opts.sleep(ctx); err != nil {
return nil, err
}
atomic.AddInt64(&c.counts.prepare, 1)
inner, err := pc.PrepareContext(ctx, query)
if err != nil {
return nil, err
}
return &wrappedStmt{inner: inner, counts: c.counts, opts: c.opts}, nil
}
func (c *wrappedConn) ExecContext(ctx context.Context, query string, args []driver.NamedValue) (driver.Result, error) {
execer, ok := c.inner.(driver.ExecerContext)
if !ok {
return nil, driver.ErrSkip
}
if err := c.opts.sleep(ctx); err != nil {
return nil, err
}
atomic.AddInt64(&c.counts.exec, 1)
return execer.ExecContext(ctx, query, args)
}
func (c *wrappedConn) QueryContext(ctx context.Context, query string, args []driver.NamedValue) (driver.Rows, error) {
queryer, ok := c.inner.(driver.QueryerContext)
if !ok {
return nil, driver.ErrSkip
}
if err := c.opts.sleep(ctx); err != nil {
return nil, err
}
atomic.AddInt64(&c.counts.query, 1)
return queryer.QueryContext(ctx, query, args)
}
func (c *wrappedConn) BeginTx(ctx context.Context, txOpts driver.TxOptions) (driver.Tx, error) {
bt, ok := c.inner.(driver.ConnBeginTx)
if !ok {
return c.Begin()
}
if err := c.opts.sleep(ctx); err != nil {
return nil, err
}
atomic.AddInt64(&c.counts.begin, 1)
inner, err := bt.BeginTx(ctx, txOpts)
if err != nil {
return nil, err
}
return &wrappedTx{inner: inner, counts: c.counts}, nil
}
func (c *wrappedConn) Ping(ctx context.Context) error {
if p, ok := c.inner.(driver.Pinger); ok {
return p.Ping(ctx)
}
return nil
}
func (c *wrappedConn) ResetSession(ctx context.Context) error {
if r, ok := c.inner.(driver.SessionResetter); ok {
return r.ResetSession(ctx)
}
return nil
}
func (c *wrappedConn) IsValid() bool {
if v, ok := c.inner.(driver.Validator); ok {
return v.IsValid()
}
return true
}
func (c *wrappedConn) CheckNamedValue(nv *driver.NamedValue) error {
if chk, ok := c.inner.(driver.NamedValueChecker); ok {
return chk.CheckNamedValue(nv)
}
return driver.ErrSkip
}
// wrappedStmt wraps a driver.Stmt the same way wrappedConn wraps a
// driver.Conn: delegate to a modern optional interface when the inner
// statement implements it, else fall back to the legacy path, and always
// implement NamedValueChecker for the reason documented on wrappedConn.
type wrappedStmt struct {
inner driver.Stmt
counts *Counts
opts *options
}
func (s *wrappedStmt) Close() error { return s.inner.Close() }
func (s *wrappedStmt) NumInput() int { return s.inner.NumInput() }
//nolint:staticcheck // legacy driver.Stmt.Exec, required by the interface and used as the ExecContext fallback below.
func (s *wrappedStmt) Exec(args []driver.Value) (driver.Result, error) {
atomic.AddInt64(&s.counts.stmtExec, 1)
return s.inner.Exec(args) //nolint:staticcheck
}
//nolint:staticcheck // legacy driver.Stmt.Query, required by the interface and used as the QueryContext fallback below.
func (s *wrappedStmt) Query(args []driver.Value) (driver.Rows, error) {
atomic.AddInt64(&s.counts.stmtQuery, 1)
return s.inner.Query(args) //nolint:staticcheck
}
func (s *wrappedStmt) ExecContext(ctx context.Context, args []driver.NamedValue) (driver.Result, error) {
if err := s.opts.sleep(ctx); err != nil {
return nil, err
}
if se, ok := s.inner.(driver.StmtExecContext); ok {
atomic.AddInt64(&s.counts.stmtExec, 1)
return se.ExecContext(ctx, args)
}
dargs, err := namedToOrdinal(args)
if err != nil {
return nil, err
}
atomic.AddInt64(&s.counts.stmtExec, 1)
return s.inner.Exec(dargs) //nolint:staticcheck
}
func (s *wrappedStmt) QueryContext(ctx context.Context, args []driver.NamedValue) (driver.Rows, error) {
if err := s.opts.sleep(ctx); err != nil {
return nil, err
}
if sq, ok := s.inner.(driver.StmtQueryContext); ok {
atomic.AddInt64(&s.counts.stmtQuery, 1)
return sq.QueryContext(ctx, args)
}
dargs, err := namedToOrdinal(args)
if err != nil {
return nil, err
}
atomic.AddInt64(&s.counts.stmtQuery, 1)
return s.inner.Query(dargs) //nolint:staticcheck
}
func (s *wrappedStmt) CheckNamedValue(nv *driver.NamedValue) error {
if chk, ok := s.inner.(driver.NamedValueChecker); ok {
return chk.CheckNamedValue(nv)
}
return driver.ErrSkip
}
// namedToOrdinal converts modern named-value args back to the legacy
// ordinal-positioned driver.Value slice Exec/Query take, for an inner
// statement that implements neither StmtExecContext nor StmtQueryContext.
// Every driver this wrapper targets (mysql, dolthub/driver) implements the
// modern interfaces, so this path is exercised only as a defensive
// fallback, never in the measured code path.
func namedToOrdinal(args []driver.NamedValue) ([]driver.Value, error) {
out := make([]driver.Value, len(args))
for _, a := range args {
if a.Name != "" {
return nil, fmt.Errorf("sqlcount: named parameter %q not supported by the wrapped driver's legacy Exec/Query", a.Name)
}
if a.Ordinal < 1 || a.Ordinal > len(args) {
return nil, fmt.Errorf("sqlcount: parameter ordinal %d out of range for %d args", a.Ordinal, len(args))
}
out[a.Ordinal-1] = a.Value
}
return out, nil
}
// wrappedTx wraps a driver.Tx purely to count Commit/Rollback; it does not
// change the transaction's behavior.
type wrappedTx struct {
inner driver.Tx
counts *Counts
}
func (t *wrappedTx) Commit() error {
atomic.AddInt64(&t.counts.commit, 1)
return t.inner.Commit()
}
func (t *wrappedTx) Rollback() error {
atomic.AddInt64(&t.counts.rollback, 1)
return t.inner.Rollback()
}