database/sql Source Reading — Practice Tasks¶

package main

import (
    "context"
    "database/sql"
    "fmt"
    "log"
    "time"

    _ "modernc.org/sqlite"
)

func main() {
    db, err := sql.Open("sqlite", ":memory:")
    if err != nil {
        log.Fatalf("open: %v", err)
    }
    defer db.Close()

    // Senior decision: Ping with a deadline. sql.Open is lazy — without
    // Ping you only discover bad DSNs on the first query. With Ping +
    // context you get a fail-fast startup check that won't hang forever
    // if the DB is unreachable.
    ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
    defer cancel()
    if err := db.PingContext(ctx); err != nil {
        log.Fatalf("ping: %v", err)
    }

    if _, err := db.ExecContext(ctx, `
        CREATE TABLE users (
            id    INTEGER PRIMARY KEY,
            name  TEXT NOT NULL,
            email TEXT NOT NULL
        )
    `); err != nil {
        log.Fatalf("create: %v", err)
    }

    if _, err := db.ExecContext(ctx,
        `INSERT INTO users(name, email) VALUES (?, ?)`,
        "Ada Lovelace", "ada@example.com",
    ); err != nil {
        log.Fatalf("insert: %v", err)
    }

    var (
        id    int64
        name  string
        email string
    )
    err = db.QueryRowContext(ctx,
        `SELECT id, name, email FROM users WHERE name = ?`,
        "Ada Lovelace",
    ).Scan(&id, &name, &email)
    if err != nil {
        // Senior decision: distinguish ErrNoRows from real DB errors.
        // The former is a normal "not found"; the latter is operational.
        // Conflating them is the single most common bug in Go DB code.
        if err == sql.ErrNoRows {
            log.Println("no user found")
            return
        }
        log.Fatalf("query: %v", err)
    }
    fmt.Printf("id=%d name=%q email=%q\n", id, name, email)
}

package main

import (
    "context"
    "database/sql"
    "errors"
    "fmt"
    "log"

    _ "modernc.org/sqlite"
)

func main() {
    db, err := sql.Open("sqlite", ":memory:")
    if err != nil {
        log.Fatal(err)
    }
    defer db.Close()
    ctx := context.Background()

    must(db.ExecContext(ctx, `CREATE TABLE items (id INTEGER PRIMARY KEY, price INTEGER)`))
    for i := 1; i <= 5; i++ {
        must(db.ExecContext(ctx, `INSERT INTO items(price) VALUES (?)`, i*100))
    }

    // Senior decision: capture the Result and ALWAYS check both calls.
    // A driver that returns LastInsertId == -1 + nil error is also a thing
    // — RowsAffected and LastInsertId are not contractually guaranteed
    // to be meaningful; they're driver hints.
    res, err := db.ExecContext(ctx,
        `UPDATE items SET price = price * 2 WHERE price < ?`, 400)
    if err != nil {
        log.Fatalf("update: %v", err)
    }
    affected, err := res.RowsAffected()
    if err != nil {
        // Senior decision: tolerate "not supported" gracefully. Some
        // drivers (especially over odd protocols) return an error here.
        // Log it; don't crash the request.
        log.Printf("RowsAffected unsupported: %v", err)
    } else {
        fmt.Printf("rows affected: %d\n", affected)
    }
    last, err := res.LastInsertId()
    if err != nil {
        log.Printf("LastInsertId unsupported: %v", err)
    } else {
        fmt.Printf("last insert id (UPDATE has none meaningful): %d\n", last)
    }

    // Compare with a real INSERT.
    res, _ = db.ExecContext(ctx, `INSERT INTO items(price) VALUES (?)`, 999)
    last, _ = res.LastInsertId()
    fmt.Printf("after INSERT, LastInsertId = %d\n", last)

    // PostgreSQL note: with lib/pq or pgx the LastInsertId call returns
    // (0, errors.New("LastInsertId is not supported by this driver")).
    // The canonical PG workaround is `INSERT ... RETURNING id` + Scan.
    _ = errors.New
}

func must(_ sql.Result, err error) {
    if err != nil {
        log.Fatal(err)
    }
}

package main

import (
    "context"
    "database/sql"
    "fmt"
    "log"

    _ "modernc.org/sqlite"
)

func main() {
    db, err := sql.Open("sqlite", ":memory:")
    if err != nil {
        log.Fatal(err)
    }
    defer db.Close()
    ctx := context.Background()

    if _, err := db.ExecContext(ctx, `CREATE TABLE nums (n INTEGER)`); err != nil {
        log.Fatal(err)
    }
    for i := 1; i <= 5; i++ {
        if _, err := db.ExecContext(ctx, `INSERT INTO nums(n) VALUES (?)`, i); err != nil {
            log.Fatal(err)
        }
    }

    rows, err := db.QueryContext(ctx, `SELECT n FROM nums WHERE n % 2 = 0 ORDER BY n`)
    if err != nil {
        log.Fatalf("query: %v", err)
    }
    // Senior decision: defer Close immediately after the Query check.
    // Putting it later opens a window where an early return leaks the
    // connection. The defer is "next physical line after err check" —
    // no exceptions.
    defer rows.Close()

    for rows.Next() {
        var n int
        if err := rows.Scan(&n); err != nil {
            log.Fatalf("scan: %v", err)
        }
        fmt.Printf("n=%d\n", n)
    }
    // Senior decision: rows.Err() AFTER the loop is mandatory. The loop
    // condition Next() returns false for EITHER end-of-rows or error.
    // Without rows.Err() you cannot tell which. Forgetting this is how
    // partial-result bugs slip past testing.
    if err := rows.Err(); err != nil {
        log.Fatalf("iter: %v", err)
    }
}

type DB struct {
    // Atomic numeric counters first — atomic.* needs 8-byte alignment on
    // 32-bit platforms, hence the documented "must be first" hack.
    waitDuration atomic.Int64 // total time waited for new connections

    connector driver.Connector // produces fresh connections
    numClosed atomic.Uint64    // closed-since-start counter for stats

    mu           sync.Mutex    // protects fields below
    freeConn     []*driverConn // IDLE pool — LIFO most-recent-first
    connRequests map[uint64]chan connRequest // pending acquirers, waked by put
    nextRequest  uint64        // next key for connRequests
    numOpen      int           // OPEN counter (used + idle)

    // openerCh is the bridge: connectionOpener pulls from it and creates
    // a fresh driver.Conn for each token, respecting maxOpen.
    openerCh    chan struct{}
    closed      bool
    dep         map[finalCloser]depSet // tracks who depends on what
    lastPut     map[*driverConn]string // debug-only: where each conn was last released
    maxIdleCount int                   // SetMaxIdleConns
    maxOpen      int                   // SetMaxOpenConns
    maxLifetime  time.Duration         // SetConnMaxLifetime
    maxIdleTime  time.Duration         // SetConnMaxIdleTime
    cleanerCh    chan struct{}         // signals the reaper to wake
    waitCount    int64                 // total connections waited for
    maxIdleClosed int64                // conns closed because freeConn was full
    maxIdleTimeClosed int64            // conns closed by idle reaper
    maxLifetimeClosed int64            // conns closed by lifetime reaper

    stop func() // called by Close to cancel background goroutines
}

package main

import (
    "context"
    "database/sql"
    "fmt"
    "log"
    "sync"
    "time"

    _ "modernc.org/sqlite"
)

func main() {
    db, err := sql.Open("sqlite", ":memory:")
    if err != nil {
        log.Fatal(err)
    }
    defer db.Close()

    // Senior decision: small numbers make the contention visible. In
    // production the rule of thumb is 2x CPU cores up to a few dozen;
    // here we want goroutines to QUEUE so DBStats moves.
    db.SetMaxOpenConns(2)
    db.SetMaxIdleConns(1)
    db.SetConnMaxLifetime(time.Minute)
    db.SetConnMaxIdleTime(30 * time.Second)

    ctx, cancel := context.WithCancel(context.Background())
    defer cancel()

    // Background DBStats printer.
    go func() {
        t := time.NewTicker(100 * time.Millisecond)
        defer t.Stop()
        for {
            select {
            case <-ctx.Done():
                return
            case <-t.C:
                s := db.Stats()
                fmt.Printf("open=%d in_use=%d idle=%d wait=%d wait_dur=%s\n",
                    s.OpenConnections, s.InUse, s.Idle,
                    s.WaitCount, s.WaitDuration)
            }
        }
    }()

    var wg sync.WaitGroup
    for i := 0; i < 10; i++ {
        wg.Add(1)
        go func(id int) {
            defer wg.Done()
            // Each goroutine: acquire a conn, do "slow work", release.
            // With MaxOpenConns=2, 8 of these wait at any given moment.
            conn, err := db.Conn(ctx)
            if err != nil {
                log.Printf("g%d: conn: %v", id, err)
                return
            }
            defer conn.Close() // returns to pool, does NOT close DB.
            if _, err := conn.ExecContext(ctx, `SELECT 1`); err != nil {
                log.Printf("g%d: exec: %v", id, err)
                return
            }
            // Senior decision: hold the conn briefly to force queueing.
            // In real code never sleep with a conn checked out — but this
            // is a teaching exercise about pool dynamics.
            time.Sleep(200 * time.Millisecond)
        }(i)
    }
    wg.Wait()
    // Final snapshot.
    s := db.Stats()
    fmt.Printf("FINAL  open=%d in_use=%d idle=%d wait=%d wait_dur=%s max_open=%d\n",
        s.OpenConnections, s.InUse, s.Idle,
        s.WaitCount, s.WaitDuration, s.MaxOpenConnections)
}

package main

import (
    "context"
    "database/sql"
    "errors"
    "fmt"
    "log"
    "os"
    "time"

    _ "github.com/jackc/pgx/v5/stdlib"
)

func main() {
    dsn := os.Getenv("DATABASE_URL")
    if dsn == "" {
        log.Fatal("set DATABASE_URL=postgres://...")
    }
    db, err := sql.Open("pgx", dsn)
    if err != nil {
        log.Fatal(err)
    }
    defer db.Close()

    ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
    defer cancel()

    // Senior decision: choose isolation by the workload, not by reflex.
    // - LevelReadCommitted (PG default): cheapest, fine for 90% of code.
    // - LevelRepeatableRead: needed if you read the same row twice and
    //   expect consistency within the tx.
    // - LevelSerializable: pay the retry cost for true conflict
    //   serialisation. Always be prepared to retry on
    //   SQLSTATE 40001 (serialization_failure).
    tx, err := db.BeginTx(ctx, &sql.TxOptions{
        Isolation: sql.LevelSerializable,
        ReadOnly:  false,
    })
    if err != nil {
        log.Fatalf("begin: %v", err)
    }
    // Senior decision: defer Rollback unconditionally. After a Commit it
    // returns ErrTxDone, which we ignore. Without the defer, every early
    // return is a tx leak — and pgx will eventually time out the abandoned
    // tx, but the user-visible failure mode is "this conn is stuck".
    defer func() {
        if rbErr := tx.Rollback(); rbErr != nil && !errors.Is(rbErr, sql.ErrTxDone) {
            log.Printf("rollback: %v", rbErr)
        }
    }()

    var level string
    if err := tx.QueryRowContext(ctx, `SHOW transaction_isolation`).Scan(&level); err != nil {
        log.Fatalf("show: %v", err)
    }
    fmt.Printf("transaction_isolation = %q\n", level)
    // Expected: "serializable"

    // Do real work; here a no-op SELECT to exercise the tx.
    var one int
    if err := tx.QueryRowContext(ctx, `SELECT 1`).Scan(&one); err != nil {
        log.Fatalf("select: %v", err)
    }

    if err := tx.Commit(); err != nil {
        // Senior decision: a SERIALIZABLE commit can fail with 40001
        // even if every statement succeeded. The retry must be at this
        // boundary, not inside the tx.
        log.Fatalf("commit: %v", err)
    }
    fmt.Println("committed")
}

package main

import (
    "context"
    "database/sql"
    "errors"
    "fmt"
    "log"
    "time"

    _ "modernc.org/sqlite"
)

func main() {
    db, err := sql.Open("sqlite", ":memory:")
    if err != nil {
        log.Fatal(err)
    }
    defer db.Close()
    db.SetMaxOpenConns(3)

    before := db.Stats()
    fmt.Printf("BEFORE open=%d numClosed=%d\n",
        before.OpenConnections, before.MaxOpenConnections)

    // Make the query slow by recursing.
    slowSQL := `
        WITH RECURSIVE r(n) AS (
            SELECT 1
            UNION ALL
            SELECT n + 1 FROM r WHERE n < 1000000
        )
        SELECT count(*) FROM r
    `

    ctx, cancel := context.WithCancel(context.Background())
    done := make(chan error, 1)
    go func() {
        var count int
        done <- db.QueryRowContext(ctx, slowSQL).Scan(&count)
    }()

    // Senior decision: give the query enough time to actually start.
    // Cancelling before the conn is checked out doesn't test cancellation
    // mid-query — it tests early-abort. Both are valid; this test wants
    // the harder case.
    time.Sleep(10 * time.Millisecond)
    cancel()

    err = <-done
    if err == nil {
        fmt.Println("query finished before cancel (try a slower query)")
    } else if errors.Is(err, context.Canceled) {
        fmt.Println("query cancelled as expected")
    } else {
        fmt.Printf("unexpected error: %v\n", err)
    }

    // Senior decision: small sleep lets the pool reaper observe the
    // poisoned conn. Without it Stats() may see it still counted.
    time.Sleep(50 * time.Millisecond)
    after := db.Stats()
    fmt.Printf("AFTER  open=%d wait=%d\n", after.OpenConnections, after.WaitCount)
    fmt.Printf("InUse=%d Idle=%d\n", after.InUse, after.Idle)
}

package main

import (
    "context"
    "database/sql"
    "database/sql/driver"
    "errors"
    "fmt"
    "log"
    "time"

    _ "modernc.org/sqlite"
)

// Retry runs fn with a connection. If fn returns driver.ErrBadConn
// (already retried once by database/sql, so this is the second failure),
// Retry tries one more time with a fresh conn.
//
// Senior decision: ONE retry. More than that and you're hammering a sick
// downstream. The whole point of ErrBadConn surfacing is "your second
// connection also died". If a third also dies, the DB is genuinely
// unreachable — bail out fast.
func Retry(ctx context.Context, db *sql.DB, fn func(context.Context, *sql.Conn) error) error {
    const attempts = 2
    var last error
    for i := 0; i < attempts; i++ {
        conn, err := db.Conn(ctx)
        if err != nil {
            return fmt.Errorf("acquire conn (attempt %d): %w", i+1, err)
        }
        err = fn(ctx, conn)
        // Senior decision: ALWAYS close the conn back to the pool. A bad
        // conn closes itself implicitly inside database/sql; a good conn
        // returns to idle.
        if cerr := conn.Close(); cerr != nil && err == nil {
            err = cerr
        }
        if err == nil {
            return nil
        }
        last = err
        // Senior decision: only retry on the very specific signal. Any
        // other error is application-domain (constraint violation, bad
        // SQL, etc.) and retrying it is wrong AND wasteful.
        if !errors.Is(err, driver.ErrBadConn) {
            return err
        }
        // Tiny backoff to give the conn opener time to dial a fresh one.
        time.Sleep(5 * time.Millisecond)
    }
    return fmt.Errorf("after %d attempts: %w", attempts, last)
}

func main() {
    db, err := sql.Open("sqlite", ":memory:")
    if err != nil {
        log.Fatal(err)
    }
    defer db.Close()

    ctx := context.Background()
    if _, err := db.ExecContext(ctx, `CREATE TABLE t(v INT)`); err != nil {
        log.Fatal(err)
    }

    err = Retry(ctx, db, func(ctx context.Context, c *sql.Conn) error {
        _, err := c.ExecContext(ctx, `INSERT INTO t(v) VALUES (?)`, 42)
        return err
    })
    if err != nil {
        log.Fatalf("retry: %v", err)
    }
    fmt.Println("ok")
}

package main

import (
    "context"
    "database/sql"
    "database/sql/driver"
    "fmt"
    "io"
    "log"
)

// Money is the custom type the driver knows how to bind.
type Money struct {
    Cents int64
}

// ----- driver.Driver -----

type fakeDriver struct{}

func (fakeDriver) Open(name string) (driver.Conn, error) {
    return &fakeConn{}, nil
}

// ----- driver.Conn -----

type fakeConn struct{}

func (c *fakeConn) Prepare(query string) (driver.Stmt, error) {
    return &fakeStmt{q: query}, nil
}
func (c *fakeConn) Close() error              { return nil }
func (c *fakeConn) Begin() (driver.Tx, error) { return nil, fmt.Errorf("tx unsupported") }

// Senior decision: implement NamedValueChecker on the Conn (not just the
// Stmt) so EVERY query path benefits, including Exec without an explicit
// Prepare. The framework probes Stmt first, then Conn — having it here is
// a belt-and-braces default for drivers that re-prepare on the fly.
func (c *fakeConn) CheckNamedValue(nv *driver.NamedValue) error {
    return coerceMoney(nv)
}

// ----- driver.Stmt -----

type fakeStmt struct{ q string }

func (s *fakeStmt) Close() error  { return nil }
func (s *fakeStmt) NumInput() int { return -1 } // "I don't know"; framework counts
func (s *fakeStmt) Exec(args []driver.Value) (driver.Result, error) {
    log.Printf("fakeStmt.Exec q=%q args=%v", s.q, args)
    return fakeResult{}, nil
}
func (s *fakeStmt) Query(args []driver.Value) (driver.Rows, error) {
    return nil, fmt.Errorf("Query unsupported in this demo")
}

// Senior decision: NamedValueChecker on Stmt overrides Conn's. We use the
// SAME coercion function from both — DRY. The contract is "modify nv.Value
// in place to something the driver can bind, or return ErrSkip to defer
// to default conversion, or return an error to reject".
func (s *fakeStmt) CheckNamedValue(nv *driver.NamedValue) error {
    return coerceMoney(nv)
}

func coerceMoney(nv *driver.NamedValue) error {
    switch v := nv.Value.(type) {
    case Money:
        // Coerce to driver.Value — must be one of:
        // int64, float64, bool, []byte, string, time.Time, or nil.
        nv.Value = v.Cents
        return nil
    case int64, string, []byte, float64, bool, nil:
        return nil
    default:
        // Defer to the default converter for everything else.
        return driver.ErrSkip
    }
}

// ----- driver.Result -----

type fakeResult struct{}

func (fakeResult) LastInsertId() (int64, error) { return 0, nil }
func (fakeResult) RowsAffected() (int64, error) { return 1, nil }

// ----- registration -----

func init() {
    sql.Register("fake", fakeDriver{})
}

func main() {
    db, err := sql.Open("fake", "anything")
    if err != nil {
        log.Fatal(err)
    }
    defer db.Close()
    ctx := context.Background()
    res, err := db.ExecContext(ctx,
        `INSERT INTO orders(total) VALUES (?)`,
        Money{Cents: 1999},
    )
    if err != nil {
        log.Fatalf("exec: %v", err)
    }
    rows, _ := res.RowsAffected()
    fmt.Printf("rows=%d (Money was bound as int64)\n", rows)
    // Demonstrate the io.EOF path is unused; keep import alive.
    _ = io.EOF
}

package main

import (
    "context"
    "database/sql"
    "errors"
    "fmt"
    "log"

    _ "modernc.org/sqlite"
)

func main() {
    db, err := sql.Open("sqlite", ":memory:")
    if err != nil {
        log.Fatal(err)
    }
    defer db.Close()
    ctx := context.Background()

    _, err = db.ExecContext(ctx, `
        CREATE TABLE t (name TEXT);
        INSERT INTO t(name) VALUES (NULL);
        INSERT INTO t(name) VALUES ('hello');
    `)
    if err != nil {
        log.Fatal(err)
    }

    // ----- Scan NULL into *string -----
    var s string
    err = db.QueryRowContext(ctx, `SELECT name FROM t WHERE name IS NULL`).Scan(&s)
    if err != nil {
        // Expected: "converting NULL to string is unsupported".
        fmt.Printf("*string + NULL -> error: %v\n", err)
    } else {
        fmt.Printf("*string + NULL -> %q (unexpected)\n", s)
    }

    // ----- Scan NULL into *sql.NullString -----
    var ns sql.NullString
    err = db.QueryRowContext(ctx, `SELECT name FROM t WHERE name IS NULL`).Scan(&ns)
    if err != nil {
        fmt.Printf("*NullString + NULL -> error: %v\n", err)
    } else {
        fmt.Printf("*NullString + NULL -> Valid=%v String=%q\n", ns.Valid, ns.String)
    }

    // ----- Scan non-NULL into both for symmetry -----
    err = db.QueryRowContext(ctx, `SELECT name FROM t WHERE name = 'hello'`).Scan(&s)
    fmt.Printf("*string + 'hello' -> %q (err=%v)\n", s, err)
    err = db.QueryRowContext(ctx, `SELECT name FROM t WHERE name = 'hello'`).Scan(&ns)
    fmt.Printf("*NullString + 'hello' -> Valid=%v String=%q (err=%v)\n", ns.Valid, ns.String, err)

    _ = errors.New
}

package main

import (
    "context"
    "database/sql"
    "log"
    "net/http"
    "time"

    "github.com/prometheus/client_golang/prometheus"
    "github.com/prometheus/client_golang/prometheus/promhttp"
    _ "modernc.org/sqlite"
)

// Senior decision: implement the Collector interface, not push to gauges
// from a goroutine. Collectors are called by promhttp at scrape time, so
// the values are fresh, the goroutine doesn't exist, and you don't burn
// CPU between scrapes.
type dbStatsCollector struct {
    db     *sql.DB
    dbName string

    maxOpen           *prometheus.Desc
    open              *prometheus.Desc
    inUse             *prometheus.Desc
    idle              *prometheus.Desc
    waitCount         *prometheus.Desc
    waitDuration      *prometheus.Desc
    maxIdleClosed     *prometheus.Desc
    maxIdleTimeClosed *prometheus.Desc
    maxLifetimeClosed *prometheus.Desc
}

func newDBStatsCollector(db *sql.DB, name string) *dbStatsCollector {
    labels := []string{"db"}
    return &dbStatsCollector{
        db:     db,
        dbName: name,
        maxOpen: prometheus.NewDesc("go_sql_max_open_connections",
            "Max open connections configured.", labels, nil),
        open: prometheus.NewDesc("go_sql_open_connections",
            "Open connections (in use + idle).", labels, nil),
        inUse: prometheus.NewDesc("go_sql_in_use_connections",
            "Connections currently checked out.", labels, nil),
        idle: prometheus.NewDesc("go_sql_idle_connections",
            "Connections currently idle in the pool.", labels, nil),
        waitCount: prometheus.NewDesc("go_sql_wait_count_total",
            "Total times a goroutine waited for a connection.", labels, nil),
        waitDuration: prometheus.NewDesc("go_sql_wait_duration_seconds_total",
            "Total time waited for connections, in seconds.", labels, nil),
        maxIdleClosed: prometheus.NewDesc("go_sql_max_idle_closed_total",
            "Connections closed due to SetMaxIdleConns.", labels, nil),
        maxIdleTimeClosed: prometheus.NewDesc("go_sql_max_idle_time_closed_total",
            "Connections closed due to SetConnMaxIdleTime.", labels, nil),
        maxLifetimeClosed: prometheus.NewDesc("go_sql_max_lifetime_closed_total",
            "Connections closed due to SetConnMaxLifetime.", labels, nil),
    }
}

func (c *dbStatsCollector) Describe(ch chan<- *prometheus.Desc) {
    ch <- c.maxOpen
    ch <- c.open
    ch <- c.inUse
    ch <- c.idle
    ch <- c.waitCount
    ch <- c.waitDuration
    ch <- c.maxIdleClosed
    ch <- c.maxIdleTimeClosed
    ch <- c.maxLifetimeClosed
}

func (c *dbStatsCollector) Collect(ch chan<- prometheus.Metric) {
    s := c.db.Stats()
    g := func(d *prometheus.Desc, v float64) {
        ch <- prometheus.MustNewConstMetric(d, prometheus.GaugeValue, v, c.dbName)
    }
    cn := func(d *prometheus.Desc, v float64) {
        ch <- prometheus.MustNewConstMetric(d, prometheus.CounterValue, v, c.dbName)
    }
    g(c.maxOpen, float64(s.MaxOpenConnections))
    g(c.open, float64(s.OpenConnections))
    g(c.inUse, float64(s.InUse))
    g(c.idle, float64(s.Idle))
    cn(c.waitCount, float64(s.WaitCount))
    cn(c.waitDuration, s.WaitDuration.Seconds())
    cn(c.maxIdleClosed, float64(s.MaxIdleClosed))
    cn(c.maxIdleTimeClosed, float64(s.MaxIdleTimeClosed))
    cn(c.maxLifetimeClosed, float64(s.MaxLifetimeClosed))
}

func main() {
    db, err := sql.Open("sqlite", ":memory:")
    if err != nil {
        log.Fatal(err)
    }
    defer db.Close()
    db.SetMaxOpenConns(8)
    db.SetMaxIdleConns(4)

    prometheus.MustRegister(newDBStatsCollector(db, "primary"))

    // Generate some traffic so the metrics are non-zero.
    go func() {
        ctx := context.Background()
        for {
            _, _ = db.ExecContext(ctx, `SELECT 1`)
            time.Sleep(100 * time.Millisecond)
        }
    }()

    http.Handle("/metrics", promhttp.Handler())
    log.Println("metrics on :2112/metrics")
    log.Fatal(http.ListenAndServe(":2112", nil))
}