15319368397

Committed 29 May 2025 08:08AM UTC coverage: 36.849% (-0.1%) from 36.981%

Build # 15319368397

Build Type

push

github

Committed by

stephenafamo

Commit Message

Import libsql driver in sqlite test

Run Details

8035 of 21805 relevant lines covered (36.85%)

185.57 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

20.48

/stdlib.go

package bob

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

        "github.com/stephenafamo/scan"
)

// Open works just like [sql.Open], but converts the returned [*sql.DB] to [DB]
func Open(driverName string, dataSource string) (DB, error) {
        db, err := sql.Open(driverName, dataSource)
        return NewDB(db), err
}

// OpenDB works just like [sql.OpenDB], but converts the returned [*sql.DB] to [DB]
func OpenDB(c driver.Connector) DB {
        return NewDB(sql.OpenDB(c))
}

// NewDB wraps an [*sql.DB] and returns a type that implements [Queryer] but still
// retains the expected methods used by *sql.DB
// This is useful when an existing *sql.DB is used in other places in the codebase
func NewDB(db *sql.DB) DB {
        return DB{db}
}

// DB is similar to *sql.DB but implement [Queryer]
type DB struct {
        *sql.DB
}

// PrepareContext creates a prepared statement for later queries or executions
func (d DB) PrepareContext(ctx context.Context, query string) (StdPrepared, error) {
        s, err := d.DB.PrepareContext(ctx, query)
        return StdPrepared{s}, err
}

// QueryContext executes a query that returns rows, typically a SELECT. The args are for any placeholder parameters in the query.
func (d DB) QueryContext(ctx context.Context, query string, args ...any) (scan.Rows, error) {
        return d.DB.QueryContext(ctx, query, args...)
}

// Begin is similar to [*sql.DB.BeginTx], but return a transaction that
// implements [Queryer]
func (d DB) Begin(ctx context.Context) (Transaction, error) {
        return d.BeginTx(ctx, nil)
}

// BeginTx is similar to [*sql.DB.BeginTx], but return a transaction that
// implements [Queryer]
func (d DB) BeginTx(ctx context.Context, opts *sql.TxOptions) (Transaction, error) {
        tx, err := d.DB.BeginTx(ctx, opts)
        if err != nil {
                return Tx{}, err
        }

        return NewTx(tx), nil
}

// RunInTx runs the provided function in a transaction.
// If the function returns an error, the transaction is rolled back.
// Otherwise, the transaction is committed.
func (d DB) RunInTx(ctx context.Context, txOptions *sql.TxOptions, fn func(context.Context, Executor) error) error {
        tx, err := d.BeginTx(ctx, txOptions)
        if err != nil {
                return fmt.Errorf("begin: %w", err)
        }

        if err := fn(ctx, tx); err != nil {
                err = fmt.Errorf("call: %w", err)

                if rollbackErr := tx.Rollback(ctx); rollbackErr != nil {
                        return errors.Join(err, rollbackErr)
                }

                return err
        }

        if err := tx.Commit(ctx); err != nil {
                return fmt.Errorf("commit: %w", err)
        }

        return nil
}

// NewTx wraps an [*sql.Tx] and returns a type that implements [Queryer] but still
// retains the expected methods used by *sql.Tx
// This is useful when an existing *sql.Tx is used in other places in the codebase
func NewTx(tx *sql.Tx) Tx {
        return Tx{tx}
}

// Tx is similar to *sql.Tx but implements [Queryer]
type Tx struct {
        *sql.Tx
}

// PrepareContext creates a prepared statement for later queries or executions
func (t Tx) PrepareContext(ctx context.Context, query string) (StdPrepared, error) {
        s, err := t.Tx.PrepareContext(ctx, query)
        return StdPrepared{s}, err
}

// QueryContext executes a query that returns rows, typically a SELECT. The args are for any placeholder parameters in the query.
func (t Tx) QueryContext(ctx context.Context, query string, args ...any) (scan.Rows, error) {
        return t.Tx.QueryContext(ctx, query, args...)
}

// Commit works the same as [*sql.Tx.Commit]
func (t Tx) Commit(_ context.Context) error {
        return t.Tx.Commit()
}

// Rollback works the same as [*sql.Tx.Rollback]
func (t Tx) Rollback(_ context.Context) error {
        return t.Tx.Rollback()
}

func (tx Tx) StmtContext(ctx context.Context, stmt StdPrepared) StdPrepared {
        return StdPrepared{tx.Tx.StmtContext(ctx, stmt.Stmt)}
}

// NewConn wraps an [*sql.Conn] and returns a type that implements [Queryer]
// This is useful when an existing *sql.Conn is used in other places in the codebase
func NewConn(conn *sql.Conn) Conn {
        return Conn{conn}
}

// Conn is similar to *sql.Conn but implements [Queryer]
type Conn struct {
        *sql.Conn
}

// PrepareContext creates a prepared statement for later queries or executions
func (d Conn) PrepareContext(ctx context.Context, query string) (StdPrepared, error) {
        s, err := d.Conn.PrepareContext(ctx, query)
        return StdPrepared{s}, err
}

// QueryContext executes a query that returns rows, typically a SELECT. The args are for any placeholder parameters in the query.
func (d Conn) QueryContext(ctx context.Context, query string, args ...any) (scan.Rows, error) {
        return d.Conn.QueryContext(ctx, query, args...)
}

// Begin is similar to [*sql.DB.BeginTx], but return a transaction that
// implements [Queryer]
func (d Conn) Begin(ctx context.Context) (Transaction, error) {
        return d.BeginTx(ctx, nil)
}

// BeginTx is similar to [*sql.DB.BeginTx], but return a transaction that
// implements [Queryer]
func (d Conn) BeginTx(ctx context.Context, opts *sql.TxOptions) (Transaction, error) {
        tx, err := d.Conn.BeginTx(ctx, opts)
        if err != nil {
                return Tx{}, err
        }

        return NewTx(tx), nil
}

type StdPrepared struct {
        *sql.Stmt
}

func (s StdPrepared) QueryContext(ctx context.Context, args ...any) (scan.Rows, error) {
        return s.Stmt.QueryContext(ctx, args...)
}

1	package bob
2
3	import (
4	"context"
5	"database/sql"
6	"database/sql/driver"
7	"errors"
8	"fmt"
9
10	"github.com/stephenafamo/scan"
11	)
12
13	// Open works just like [sql.Open], but converts the returned [*sql.DB] to [DB]
14	func Open(driverName string, dataSource string) (DB, error) {	2✔
15	db, err := sql.Open(driverName, dataSource)	2✔
16	return NewDB(db), err	2✔
17	}	2✔
18
19	// OpenDB works just like [sql.OpenDB], but converts the returned [*sql.DB] to [DB]
20	func OpenDB(c driver.Connector) DB {	×
21	return NewDB(sql.OpenDB(c))	×
22	}	×
23
24	// NewDB wraps an [*sql.DB] and returns a type that implements [Queryer] but still
25	// retains the expected methods used by *sql.DB
26	// This is useful when an existing *sql.DB is used in other places in the codebase
27	func NewDB(db *sql.DB) DB {	2✔
28	return DB{db}	2✔
29	}	2✔
30
31	// DB is similar to *sql.DB but implement [Queryer]
32	type DB struct {
33	*sql.DB
34	}
35
36	// PrepareContext creates a prepared statement for later queries or executions
37	func (d DB) PrepareContext(ctx context.Context, query string) (StdPrepared, error) {	×
38	s, err := d.DB.PrepareContext(ctx, query)	×
39	return StdPrepared{s}, err	×
40	}	×
41
42	// QueryContext executes a query that returns rows, typically a SELECT. The args are for any placeholder parameters in the query.
43	func (d DB) QueryContext(ctx context.Context, query string, args ...any) (scan.Rows, error) {	×
44	return d.DB.QueryContext(ctx, query, args...)	×
45	}	×
46
47	// Begin is similar to [*sql.DB.BeginTx], but return a transaction that
48	// implements [Queryer]
49	func (d DB) Begin(ctx context.Context) (Transaction, error) {	×
50	return d.BeginTx(ctx, nil)	×
51	}	×
52
53	// BeginTx is similar to [*sql.DB.BeginTx], but return a transaction that
54	// implements [Queryer]
55	func (d DB) BeginTx(ctx context.Context, opts *sql.TxOptions) (Transaction, error) {	2✔
56	tx, err := d.DB.BeginTx(ctx, opts)	2✔
57	if err != nil {	2✔
58	return Tx{}, err	×
59	}	×
60
61	return NewTx(tx), nil	2✔
62	}
63
64	// RunInTx runs the provided function in a transaction.
65	// If the function returns an error, the transaction is rolled back.
66	// Otherwise, the transaction is committed.
67	func (d DB) RunInTx(ctx context.Context, txOptions *sql.TxOptions, fn func(context.Context, Executor) error) error {	×
68	tx, err := d.BeginTx(ctx, txOptions)	×
69	if err != nil {	×
70	return fmt.Errorf("begin: %w", err)	×
71	}	×
72
73	if err := fn(ctx, tx); err != nil {	×
74	err = fmt.Errorf("call: %w", err)	×
75		×
76	if rollbackErr := tx.Rollback(ctx); rollbackErr != nil {	×
77	return errors.Join(err, rollbackErr)	×
78	}	×
79
80	return err	×
81	}
82
83	if err := tx.Commit(ctx); err != nil {	×
84	return fmt.Errorf("commit: %w", err)	×
85	}	×
86
87	return nil	×
88	}
89
90	// NewTx wraps an [*sql.Tx] and returns a type that implements [Queryer] but still
91	// retains the expected methods used by *sql.Tx
92	// This is useful when an existing *sql.Tx is used in other places in the codebase
93	func NewTx(tx *sql.Tx) Tx {	2✔
94	return Tx{tx}	2✔
95	}	2✔
96
97	// Tx is similar to *sql.Tx but implements [Queryer]
98	type Tx struct {
99	*sql.Tx
100	}
101
102	// PrepareContext creates a prepared statement for later queries or executions
103	func (t Tx) PrepareContext(ctx context.Context, query string) (StdPrepared, error) {	×
104	s, err := t.Tx.PrepareContext(ctx, query)	×
105	return StdPrepared{s}, err	×
106	}	×
107
108	// QueryContext executes a query that returns rows, typically a SELECT. The args are for any placeholder parameters in the query.
109	func (t Tx) QueryContext(ctx context.Context, query string, args ...any) (scan.Rows, error) {	4✔
110	return t.Tx.QueryContext(ctx, query, args...)	4✔
111	}	4✔
112
113	// Commit works the same as [*sql.Tx.Commit]
114	func (t Tx) Commit(_ context.Context) error {	×
115	return t.Tx.Commit()	×
116	}	×
117
118	// Rollback works the same as [*sql.Tx.Rollback]
119	func (t Tx) Rollback(_ context.Context) error {	×
120	return t.Tx.Rollback()	×
121	}	×
122
123	func (tx Tx) StmtContext(ctx context.Context, stmt StdPrepared) StdPrepared {	×
124	return StdPrepared{tx.Tx.StmtContext(ctx, stmt.Stmt)}	×
125	}	×
126
127	// NewConn wraps an [*sql.Conn] and returns a type that implements [Queryer]
128	// This is useful when an existing *sql.Conn is used in other places in the codebase
129	func NewConn(conn *sql.Conn) Conn {	×
130	return Conn{conn}	×
131	}	×
132
133	// Conn is similar to *sql.Conn but implements [Queryer]
134	type Conn struct {
135	*sql.Conn
136	}
137
138	// PrepareContext creates a prepared statement for later queries or executions
139	func (d Conn) PrepareContext(ctx context.Context, query string) (StdPrepared, error) {	×
140	s, err := d.Conn.PrepareContext(ctx, query)	×
141	return StdPrepared{s}, err	×
142	}	×
143
144	// QueryContext executes a query that returns rows, typically a SELECT. The args are for any placeholder parameters in the query.
145	func (d Conn) QueryContext(ctx context.Context, query string, args ...any) (scan.Rows, error) {	×
146	return d.Conn.QueryContext(ctx, query, args...)	×
147	}	×
148
149	// Begin is similar to [*sql.DB.BeginTx], but return a transaction that
150	// implements [Queryer]
151	func (d Conn) Begin(ctx context.Context) (Transaction, error) {	×
152	return d.BeginTx(ctx, nil)	×
153	}	×
154
155	// BeginTx is similar to [*sql.DB.BeginTx], but return a transaction that
156	// implements [Queryer]
157	func (d Conn) BeginTx(ctx context.Context, opts *sql.TxOptions) (Transaction, error) {	×
158	tx, err := d.Conn.BeginTx(ctx, opts)	×
159	if err != nil {	×
160	return Tx{}, err	×
161	}	×
162
163	return NewTx(tx), nil	×
164	}
165
166	type StdPrepared struct {
167	*sql.Stmt
168	}
169
170	func (s StdPrepared) QueryContext(ctx context.Context, args ...any) (scan.Rows, error) {	×
171	return s.Stmt.QueryContext(ctx, args...)	×
172	}	×

stephenafamo / bob / 15319368397

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous