* 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>
417 lines
14 KiB
Go
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()
|
|
}
|