package sql

Import Path
	database/sql (on go.dev)

Dependency Relation
	imports 17 packages, and imported by 0 packages

Involved Source Files

	    convert.go
	    ctxutil.go
	  d sql.go
		Package sql provides a generic interface around SQL (or SQL-like)
		databases.
		
		The sql package must be used in conjunction with a database driver.
		See https://golang.org/s/sqldrivers for a list of drivers.
		
		Drivers that do not support context cancellation will not return until
		after the query is completed.
		
		For usage examples, see the wiki page at
		https://golang.org/s/sqlwiki.
Code Examples

	Conn_ExecContext
		package main
		
		import (
			"context"
			"database/sql"
			"log"
		)
		
		var (
			ctx context.Context
			db  *sql.DB
		)
		
		func main() {
			// A *DB is a pool of connections. Call Conn to reserve a connection for
			// exclusive use.
			conn, err := db.Conn(ctx)
			if err != nil {
				log.Fatal(err)
			}
			defer conn.Close() // Return the connection to the pool.
			id := 41
			result, err := conn.ExecContext(ctx, `UPDATE balances SET balance = balance + 10 WHERE user_id = ?;`, id)
			if err != nil {
				log.Fatal(err)
			}
			rows, err := result.RowsAffected()
			if err != nil {
				log.Fatal(err)
			}
			if rows != 1 {
				log.Fatalf("expected single row affected, got %d rows affected", rows)
			}
		}

	DB_BeginTx
		package main
		
		import (
			"context"
			"database/sql"
			"log"
		)
		
		var (
			ctx context.Context
			db  *sql.DB
		)
		
		func main() {
			tx, err := db.BeginTx(ctx, &sql.TxOptions{Isolation: sql.LevelSerializable})
			if err != nil {
				log.Fatal(err)
			}
			id := 37
			_, execErr := tx.Exec(`UPDATE users SET status = ? WHERE id = ?`, "paid", id)
			if execErr != nil {
				_ = tx.Rollback()
				log.Fatal(execErr)
			}
			if err := tx.Commit(); err != nil {
				log.Fatal(err)
			}
		}

	DB_ExecContext
		package main
		
		import (
			"context"
			"database/sql"
			"log"
		)
		
		var (
			ctx context.Context
			db  *sql.DB
		)
		
		func main() {
			id := 47
			result, err := db.ExecContext(ctx, "UPDATE balances SET balance = balance + 10 WHERE user_id = ?", id)
			if err != nil {
				log.Fatal(err)
			}
			rows, err := result.RowsAffected()
			if err != nil {
				log.Fatal(err)
			}
			if rows != 1 {
				log.Fatalf("expected to affect 1 row, affected %d", rows)
			}
		}

	DB_PingContext
		package main
		
		import (
			"context"
			"database/sql"
			"log"
			"time"
		)
		
		var (
			ctx context.Context
			db  *sql.DB
		)
		
		func main() {
			// Ping and PingContext may be used to determine if communication with
			// the database server is still possible.
			//
			// When used in a command line application Ping may be used to establish
			// that further queries are possible; that the provided DSN is valid.
			//
			// When used in long running service Ping may be part of the health
			// checking system.
		
			ctx, cancel := context.WithTimeout(ctx, 1*time.Second)
			defer cancel()
		
			status := "up"
			if err := db.PingContext(ctx); err != nil {
				status = "down"
			}
			log.Println(status)
		}

	DB_Prepare
		package main
		
		import (
			"context"
			"database/sql"
			"log"
		)
		
		var db *sql.DB
		
		func main() {
			projects := []struct {
				mascot  string
				release int
			}{
				{"tux", 1991},
				{"duke", 1996},
				{"gopher", 2009},
				{"moby dock", 2013},
			}
		
			stmt, err := db.Prepare("INSERT INTO projects(id, mascot, release, category) VALUES( ?, ?, ?, ? )")
			if err != nil {
				log.Fatal(err)
			}
			defer stmt.Close() // Prepared statements take up server resources and should be closed after use.
		
			for id, project := range projects {
				if _, err := stmt.Exec(id+1, project.mascot, project.release, "open source"); err != nil {
					log.Fatal(err)
				}
			}
		}

	DB_QueryContext
		package main
		
		import (
			"context"
			"database/sql"
			"fmt"
			"log"
			"strings"
		)
		
		var (
			ctx context.Context
			db  *sql.DB
		)
		
		func main() {
			age := 27
			rows, err := db.QueryContext(ctx, "SELECT name FROM users WHERE age=?", age)
			if err != nil {
				log.Fatal(err)
			}
			defer rows.Close()
			names := make([]string, 0)
		
			for rows.Next() {
				var name string
				if err := rows.Scan(&name); err != nil {
					// Check for a scan error.
					// Query rows will be closed with defer.
					log.Fatal(err)
				}
				names = append(names, name)
			}
			// If the database is being written to ensure to check for Close
			// errors that may be returned from the driver. The query may
			// encounter an auto-commit error and be forced to rollback changes.
			rerr := rows.Close()
			if rerr != nil {
				log.Fatal(rerr)
			}
		
			// Rows.Err will report the last error encountered by Rows.Scan.
			if err := rows.Err(); err != nil {
				log.Fatal(err)
			}
			fmt.Printf("%s are %d years old", strings.Join(names, ", "), age)
		}

	DB_QueryRowContext
		package main
		
		import (
			"context"
			"database/sql"
			"log"
			"time"
		)
		
		var (
			ctx context.Context
			db  *sql.DB
		)
		
		func main() {
			id := 123
			var username string
			var created time.Time
			err := db.QueryRowContext(ctx, "SELECT username, created_at FROM users WHERE id=?", id).Scan(&username, &created)
			switch {
			case err == sql.ErrNoRows:
				log.Printf("no user with id %d\n", id)
			case err != nil:
				log.Fatalf("query error: %v\n", err)
			default:
				log.Printf("username is %q, account created on %s\n", username, created)
			}
		}

	DB_Query_multipleResultSets
		package main
		
		import (
			"context"
			"database/sql"
			"log"
		)
		
		var db *sql.DB
		
		func main() {
			age := 27
			q := `
		create temp table uid (id bigint); -- Create temp table for queries.
		insert into uid
		select id from users where age < ?; -- Populate temp table.
		
		-- First result set.
		select
			users.id, name
		from
			users
			join uid on users.id = uid.id
		;
		
		-- Second result set.
		select 
			ur.user, ur.role
		from
			user_roles as ur
			join uid on uid.id = ur.user
		;
			`
			rows, err := db.Query(q, age)
			if err != nil {
				log.Fatal(err)
			}
			defer rows.Close()
		
			for rows.Next() {
				var (
					id   int64
					name string
				)
				if err := rows.Scan(&id, &name); err != nil {
					log.Fatal(err)
				}
				log.Printf("id %d name is %s\n", id, name)
			}
			if !rows.NextResultSet() {
				log.Fatalf("expected more result sets: %v", rows.Err())
			}
			var roleMap = map[int64]string{
				1: "user",
				2: "admin",
				3: "gopher",
			}
			for rows.Next() {
				var (
					id   int64
					role int64
				)
				if err := rows.Scan(&id, &role); err != nil {
					log.Fatal(err)
				}
				log.Printf("id %d has role %s\n", id, roleMap[role])
			}
			if err := rows.Err(); err != nil {
				log.Fatal(err)
			}
		}

	Rows
		package main
		
		import (
			"context"
			"database/sql"
			"log"
			"strings"
		)
		
		var (
			ctx context.Context
			db  *sql.DB
		)
		
		func main() {
			age := 27
			rows, err := db.QueryContext(ctx, "SELECT name FROM users WHERE age=?", age)
			if err != nil {
				log.Fatal(err)
			}
			defer rows.Close()
		
			names := make([]string, 0)
			for rows.Next() {
				var name string
				if err := rows.Scan(&name); err != nil {
					log.Fatal(err)
				}
				names = append(names, name)
			}
			// Check for errors from iterating over rows.
			if err := rows.Err(); err != nil {
				log.Fatal(err)
			}
			log.Printf("%s are %d years old", strings.Join(names, ", "), age)
		}

	Stmt
		package main
		
		import (
			"context"
			"database/sql"
			"log"
		)
		
		var (
			ctx context.Context
			db  *sql.DB
		)
		
		func main() {
			// In normal use, create one Stmt when your process starts.
			stmt, err := db.PrepareContext(ctx, "SELECT username FROM users WHERE id = ?")
			if err != nil {
				log.Fatal(err)
			}
			defer stmt.Close()
		
			// Then reuse it each time you need to issue the query.
			id := 43
			var username string
			err = stmt.QueryRowContext(ctx, id).Scan(&username)
			switch {
			case err == sql.ErrNoRows:
				log.Fatalf("no user with id %d", id)
			case err != nil:
				log.Fatal(err)
			default:
				log.Printf("username is %s\n", username)
			}
		}

	Stmt_QueryRowContext
		package main
		
		import (
			"context"
			"database/sql"
			"log"
		)
		
		var (
			ctx context.Context
			db  *sql.DB
		)
		
		func main() {
			// In normal use, create one Stmt when your process starts.
			stmt, err := db.PrepareContext(ctx, "SELECT username FROM users WHERE id = ?")
			if err != nil {
				log.Fatal(err)
			}
			defer stmt.Close()
		
			// Then reuse it each time you need to issue the query.
			id := 43
			var username string
			err = stmt.QueryRowContext(ctx, id).Scan(&username)
			switch {
			case err == sql.ErrNoRows:
				log.Fatalf("no user with id %d", id)
			case err != nil:
				log.Fatal(err)
			default:
				log.Printf("username is %s\n", username)
			}
		}

	Tx_ExecContext
		package main
		
		import (
			"context"
			"database/sql"
			"log"
		)
		
		var (
			ctx context.Context
			db  *sql.DB
		)
		
		func main() {
			tx, err := db.BeginTx(ctx, &sql.TxOptions{Isolation: sql.LevelSerializable})
			if err != nil {
				log.Fatal(err)
			}
			id := 37
			_, execErr := tx.ExecContext(ctx, "UPDATE users SET status = ? WHERE id = ?", "paid", id)
			if execErr != nil {
				if rollbackErr := tx.Rollback(); rollbackErr != nil {
					log.Fatalf("update failed: %v, unable to rollback: %v\n", execErr, rollbackErr)
				}
				log.Fatalf("update failed: %v", execErr)
			}
			if err := tx.Commit(); err != nil {
				log.Fatal(err)
			}
		}

	Tx_Prepare
		package main
		
		import (
			"context"
			"database/sql"
			"log"
		)
		
		var db *sql.DB
		
		func main() {
			projects := []struct {
				mascot  string
				release int
			}{
				{"tux", 1991},
				{"duke", 1996},
				{"gopher", 2009},
				{"moby dock", 2013},
			}
		
			tx, err := db.Begin()
			if err != nil {
				log.Fatal(err)
			}
			defer tx.Rollback() // The rollback will be ignored if the tx has been committed later in the function.
		
			stmt, err := tx.Prepare("INSERT INTO projects(id, mascot, release, category) VALUES( ?, ?, ?, ? )")
			if err != nil {
				log.Fatal(err)
			}
			defer stmt.Close() // Prepared statements take up server resources and should be closed after use.
		
			for id, project := range projects {
				if _, err := stmt.Exec(id+1, project.mascot, project.release, "open source"); err != nil {
					log.Fatal(err)
				}
			}
			if err := tx.Commit(); err != nil {
				log.Fatal(err)
			}
		}

	Tx_Rollback
		package main
		
		import (
			"context"
			"database/sql"
			"log"
		)
		
		var (
			ctx context.Context
			db  *sql.DB
		)
		
		func main() {
			tx, err := db.BeginTx(ctx, &sql.TxOptions{Isolation: sql.LevelSerializable})
			if err != nil {
				log.Fatal(err)
			}
			id := 53
			_, err = tx.ExecContext(ctx, "UPDATE drivers SET status = ? WHERE id = ?;", "assigned", id)
			if err != nil {
				if rollbackErr := tx.Rollback(); rollbackErr != nil {
					log.Fatalf("update drivers: unable to rollback: %v", rollbackErr)
				}
				log.Fatal(err)
			}
			_, err = tx.ExecContext(ctx, "UPDATE pickups SET driver_id = $1;", id)
			if err != nil {
				if rollbackErr := tx.Rollback(); rollbackErr != nil {
					log.Fatalf("update failed: %v, unable to back: %v", err, rollbackErr)
				}
				log.Fatal(err)
			}
			if err := tx.Commit(); err != nil {
				log.Fatal(err)
			}
		}

	_openDBCLI
		package main
		
		import (
			"context"
			"database/sql"
			"flag"
			"log"
			"os"
			"os/signal"
			"time"
		)
		
		var pool *sql.DB // Database connection pool.
		
		func main() {
			id := flag.Int64("id", 0, "person ID to find")
			dsn := flag.String("dsn", os.Getenv("DSN"), "connection data source name")
			flag.Parse()
		
			if len(*dsn) == 0 {
				log.Fatal("missing dsn flag")
			}
			if *id == 0 {
				log.Fatal("missing person ID")
			}
			var err error
		
			// Opening a driver typically will not attempt to connect to the database.
			pool, err = sql.Open("driver-name", *dsn)
			if err != nil {
				// This will not be a connection error, but a DSN parse error or
				// another initialization error.
				log.Fatal("unable to use data source name", err)
			}
			defer pool.Close()
		
			pool.SetConnMaxLifetime(0)
			pool.SetMaxIdleConns(3)
			pool.SetMaxOpenConns(3)
		
			ctx, stop := context.WithCancel(context.Background())
			defer stop()
		
			appSignal := make(chan os.Signal, 3)
			signal.Notify(appSignal, os.Interrupt)
		
			go func() {
				<-appSignal
				stop()
			}()
		
			Ping(ctx)
		
			Query(ctx, *id)
		}
		
		// Ping the database to verify DSN provided by the user is valid and the
		// server accessible. If the ping fails exit the program with an error.
		func Ping(ctx context.Context) {
			ctx, cancel := context.WithTimeout(ctx, 1*time.Second)
			defer cancel()
		
			if err := pool.PingContext(ctx); err != nil {
				log.Fatalf("unable to connect to database: %v", err)
			}
		}
		
		// Query the database for the information requested and prints the results.
		// If the query fails exit the program with an error.
		func Query(ctx context.Context, id int64) {
			ctx, cancel := context.WithTimeout(ctx, 5*time.Second)
			defer cancel()
		
			var name string
			err := pool.QueryRowContext(ctx, "select p.name from people as p where p.id = :id;", sql.Named("id", id)).Scan(&name)
			if err != nil {
				log.Fatal("unable to execute search query", err)
			}
			log.Println("name=", name)
		}

	_openDBService
		package main
		
		import (
			"context"
			"database/sql"
			"encoding/json"
			"fmt"
			"io"
			"log"
			"net/http"
			"time"
		)
		
		func main() {
			// Opening a driver typically will not attempt to connect to the database.
			db, err := sql.Open("driver-name", "database=test1")
			if err != nil {
				// This will not be a connection error, but a DSN parse error or
				// another initialization error.
				log.Fatal(err)
			}
			db.SetConnMaxLifetime(0)
			db.SetMaxIdleConns(50)
			db.SetMaxOpenConns(50)
		
			s := &Service{db: db}
		
			http.ListenAndServe(":8080", s)
		}
		
		type Service struct {
			db *sql.DB
		}
		
		func (s *Service) ServeHTTP(w http.ResponseWriter, r *http.Request) {
			db := s.db
			switch r.URL.Path {
			default:
				http.Error(w, "not found", http.StatusNotFound)
				return
			case "/healthz":
				ctx, cancel := context.WithTimeout(r.Context(), 1*time.Second)
				defer cancel()
		
				err := s.db.PingContext(ctx)
				if err != nil {
					http.Error(w, fmt.Sprintf("db down: %v", err), http.StatusFailedDependency)
					return
				}
				w.WriteHeader(http.StatusOK)
				return
			case "/quick-action":
				// This is a short SELECT. Use the request context as the base of
				// the context timeout.
				ctx, cancel := context.WithTimeout(r.Context(), 3*time.Second)
				defer cancel()
		
				id := 5
				org := 10
				var name string
				err := db.QueryRowContext(ctx, `
		select
			p.name
		from
			people as p
			join organization as o on p.organization = o.id
		where
			p.id = :id
			and o.id = :org
		;`,
					sql.Named("id", id),
					sql.Named("org", org),
				).Scan(&name)
				if err != nil {
					if err == sql.ErrNoRows {
						http.Error(w, "not found", http.StatusNotFound)
						return
					}
					http.Error(w, err.Error(), http.StatusInternalServerError)
					return
				}
				io.WriteString(w, name)
				return
			case "/long-action":
				// This is a long SELECT. Use the request context as the base of
				// the context timeout, but give it some time to finish. If
				// the client cancels before the query is done the query will also
				// be canceled.
				ctx, cancel := context.WithTimeout(r.Context(), 60*time.Second)
				defer cancel()
		
				var names []string
				rows, err := db.QueryContext(ctx, "select p.name from people as p where p.active = true;")
				if err != nil {
					http.Error(w, err.Error(), http.StatusInternalServerError)
					return
				}
		
				for rows.Next() {
					var name string
					err = rows.Scan(&name)
					if err != nil {
						break
					}
					names = append(names, name)
				}
				// Check for errors during rows "Close".
				// This may be more important if multiple statements are executed
				// in a single batch and rows were written as well as read.
				if closeErr := rows.Close(); closeErr != nil {
					http.Error(w, closeErr.Error(), http.StatusInternalServerError)
					return
				}
		
				// Check for row scan error.
				if err != nil {
					http.Error(w, err.Error(), http.StatusInternalServerError)
					return
				}
		
				// Check for errors during row iteration.
				if err = rows.Err(); err != nil {
					http.Error(w, err.Error(), http.StatusInternalServerError)
					return
				}
		
				json.NewEncoder(w).Encode(names)
				return
			case "/async-action":
				// This action has side effects that we want to preserve
				// even if the client cancels the HTTP request part way through.
				// For this we do not use the http request context as a base for
				// the timeout.
				ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
				defer cancel()
		
				var orderRef = "ABC123"
				tx, err := db.BeginTx(ctx, &sql.TxOptions{Isolation: sql.LevelSerializable})
				if err != nil {
					http.Error(w, err.Error(), http.StatusInternalServerError)
					return
				}
				_, err = tx.ExecContext(ctx, "stored_proc_name", orderRef)
		
				if err != nil {
					tx.Rollback()
					http.Error(w, err.Error(), http.StatusInternalServerError)
					return
				}
				err = tx.Commit()
				if err != nil {
					http.Error(w, "action in unknown state, check state before attempting again", http.StatusInternalServerError)
					return
				}
				w.WriteHeader(http.StatusOK)
				return
			}
		}


Package-Level Type Names (total 24)

	/* sort by: alphabet | popularity */
	 type ColumnType (struct)
		ColumnType contains the name and type of a column.

		Methods (total 6)
			(*ColumnType) DatabaseTypeName() string
				DatabaseTypeName returns the database system name of the column type. If an empty
				string is returned, then the driver type name is not supported.
				Consult your driver documentation for a list of driver data types. [ColumnType.Length] specifiers
				are not included.
				Common type names include "VARCHAR", "TEXT", "NVARCHAR", "DECIMAL", "BOOL",
				"INT", and "BIGINT".

			(*ColumnType) DecimalSize() (precision, scale int64, ok bool)
				DecimalSize returns the scale and precision of a decimal type.
				If not applicable or if not supported ok is false.

			(*ColumnType) Length() (length int64, ok bool)
				Length returns the column type length for variable length column types such
				as text and binary field types. If the type length is unbounded the value will
				be [math.MaxInt64] (any database limits will still apply).
				If the column type is not variable length, such as an int, or if not supported
				by the driver ok is false.

			(*ColumnType) Name() string
				Name returns the name or alias of the column.

			(*ColumnType) Nullable() (nullable, ok bool)
				Nullable reports whether the column may be null.
				If a driver does not support this property ok will be false.

			(*ColumnType) ScanType() reflect.Type
				ScanType returns a Go type suitable for scanning into using [Rows.Scan].
				If a driver does not support this property ScanType will return
				the type of an empty interface.

		As Outputs Of (at least one exported)
			func (*Rows).ColumnTypes() ([]*ColumnType, error)

	 type Conn (struct)
		Conn represents a single database connection rather than a pool of database
		connections. Prefer running queries from [DB] unless there is a specific
		need for a continuous single database connection.
		
		A Conn must call [Conn.Close] to return the connection to the database pool
		and may do so concurrently with a running query.
		
		After a call to [Conn.Close], all operations on the
		connection fail with [ErrConnDone].

		Methods (total 8)
			(*Conn) BeginTx(ctx context.Context, opts *TxOptions) (*Tx, error)
				BeginTx starts a transaction.
				
				The provided context is used until the transaction is committed or rolled back.
				If the context is canceled, the sql package will roll back
				the transaction. [Tx.Commit] will return an error if the context provided to
				BeginTx is canceled.
				
				The provided [TxOptions] is optional and may be nil if defaults should be used.
				If a non-default isolation level is used that the driver doesn't support,
				an error will be returned.

			(*Conn) Close() error
				Close returns the connection to the connection pool.
				All operations after a Close will return with [ErrConnDone].
				Close is safe to call concurrently with other operations and will
				block until all other operations finish. It may be useful to first
				cancel any used context and then call close directly after.

			(*Conn) ExecContext(ctx context.Context, query string, args ...any) (Result, error)
				ExecContext executes a query without returning any rows.
				The args are for any placeholder parameters in the query.

			(*Conn) PingContext(ctx context.Context) error
				PingContext verifies the connection to the database is still alive.

			(*Conn) PrepareContext(ctx context.Context, query string) (*Stmt, error)
				PrepareContext creates a prepared statement for later queries or executions.
				Multiple queries or executions may be run concurrently from the
				returned statement.
				The caller must call the statement's [*Stmt.Close] method
				when the statement is no longer needed.
				
				The provided context is used for the preparation of the statement, not for the
				execution of the statement.

			(*Conn) QueryContext(ctx context.Context, query string, args ...any) (*Rows, error)
				QueryContext executes a query that returns rows, typically a SELECT.
				The args are for any placeholder parameters in the query.

			(*Conn) QueryRowContext(ctx context.Context, query string, args ...any) *Row
				QueryRowContext executes a query that is expected to return at most one row.
				QueryRowContext always returns a non-nil value. Errors are deferred until
				the [*Row.Scan] method is called.
				If the query selects no rows, the [*Row.Scan] will return [ErrNoRows].
				Otherwise, the [*Row.Scan] scans the first selected row and discards
				the rest.

			(*Conn) Raw(f func(driverConn any) error) (err error)
				Raw executes f exposing the underlying driver connection for the
				duration of f. The driverConn must not be used outside of f.
				
				Once f returns and err is not [driver.ErrBadConn], the [Conn] will continue to be usable
				until [Conn.Close] is called.

		Implements (at least one exported)
			*Conn : io.Closer
		As Outputs Of (at least one exported)
			func (*DB).Conn(ctx context.Context) (*Conn, error)

	 type DB (struct)
		DB is a database handle representing a pool of zero or more
		underlying connections. It's safe for concurrent use by multiple
		goroutines.
		
		The sql package creates and frees connections automatically; it
		also maintains a free pool of idle connections. If the database has
		a concept of per-connection state, such state can be reliably observed
		within a transaction ([Tx]) or connection ([Conn]). Once [DB.Begin] is called, the
		returned [Tx] is bound to a single connection. Once [Tx.Commit] or
		[Tx.Rollback] is called on the transaction, that transaction's
		connection is returned to [DB]'s idle connection pool. The pool size
		can be controlled with [DB.SetMaxIdleConns].

		Methods (total 20)
			(*DB) Begin() (*Tx, error)
				Begin starts a transaction. The default isolation level is dependent on
				the driver.
				
				Begin uses [context.Background] internally; to specify the context, use
				[DB.BeginTx].

			(*DB) BeginTx(ctx context.Context, opts *TxOptions) (*Tx, error)
				BeginTx starts a transaction.
				
				The provided context is used until the transaction is committed or rolled back.
				If the context is canceled, the sql package will roll back
				the transaction. [Tx.Commit] will return an error if the context provided to
				BeginTx is canceled.
				
				The provided [TxOptions] is optional and may be nil if defaults should be used.
				If a non-default isolation level is used that the driver doesn't support,
				an error will be returned.

			(*DB) Close() error
				Close closes the database and prevents new queries from starting.
				Close then waits for all queries that have started processing on the server
				to finish.
				
				It is rare to Close a [DB], as the [DB] handle is meant to be
				long-lived and shared between many goroutines.

			(*DB) Conn(ctx context.Context) (*Conn, error)
				Conn returns a single connection by either opening a new connection
				or returning an existing connection from the connection pool. Conn will
				block until either a connection is returned or ctx is canceled.
				Queries run on the same Conn will be run in the same database session.
				
				Every Conn must be returned to the database pool after use by
				calling [Conn.Close].

			(*DB) Driver() driver.Driver
				Driver returns the database's underlying driver.

			(*DB) Exec(query string, args ...any) (Result, error)
				Exec executes a query without returning any rows.
				The args are for any placeholder parameters in the query.
				
				Exec uses [context.Background] internally; to specify the context, use
				[DB.ExecContext].

			(*DB) ExecContext(ctx context.Context, query string, args ...any) (Result, error)
				ExecContext executes a query without returning any rows.
				The args are for any placeholder parameters in the query.

			(*DB) Ping() error
				Ping verifies a connection to the database is still alive,
				establishing a connection if necessary.
				
				Ping uses [context.Background] internally; to specify the context, use
				[DB.PingContext].

			(*DB) PingContext(ctx context.Context) error
				PingContext verifies a connection to the database is still alive,
				establishing a connection if necessary.

			(*DB) Prepare(query string) (*Stmt, error)
				Prepare creates a prepared statement for later queries or executions.
				Multiple queries or executions may be run concurrently from the
				returned statement.
				The caller must call the statement's [*Stmt.Close] method
				when the statement is no longer needed.
				
				Prepare uses [context.Background] internally; to specify the context, use
				[DB.PrepareContext].

			(*DB) PrepareContext(ctx context.Context, query string) (*Stmt, error)
				PrepareContext creates a prepared statement for later queries or executions.
				Multiple queries or executions may be run concurrently from the
				returned statement.
				The caller must call the statement's [*Stmt.Close] method
				when the statement is no longer needed.
				
				The provided context is used for the preparation of the statement, not for the
				execution of the statement.

			(*DB) Query(query string, args ...any) (*Rows, error)
				Query executes a query that returns rows, typically a SELECT.
				The args are for any placeholder parameters in the query.
				
				Query uses [context.Background] internally; to specify the context, use
				[DB.QueryContext].

			(*DB) QueryContext(ctx context.Context, query string, args ...any) (*Rows, error)
				QueryContext executes a query that returns rows, typically a SELECT.
				The args are for any placeholder parameters in the query.

			(*DB) QueryRow(query string, args ...any) *Row
				QueryRow executes a query that is expected to return at most one row.
				QueryRow always returns a non-nil value. Errors are deferred until
				[Row]'s Scan method is called.
				If the query selects no rows, the [*Row.Scan] will return [ErrNoRows].
				Otherwise, [*Row.Scan] scans the first selected row and discards
				the rest.
				
				QueryRow uses [context.Background] internally; to specify the context, use
				[DB.QueryRowContext].

			(*DB) QueryRowContext(ctx context.Context, query string, args ...any) *Row
				QueryRowContext executes a query that is expected to return at most one row.
				QueryRowContext always returns a non-nil value. Errors are deferred until
				[Row]'s Scan method is called.
				If the query selects no rows, the [*Row.Scan] will return [ErrNoRows].
				Otherwise, [*Row.Scan] scans the first selected row and discards
				the rest.

			(*DB) SetConnMaxIdleTime(d time.Duration)
				SetConnMaxIdleTime sets the maximum amount of time a connection may be idle.
				
				Expired connections may be closed lazily before reuse.
				
				If d <= 0, connections are not closed due to a connection's idle time.

			(*DB) SetConnMaxLifetime(d time.Duration)
				SetConnMaxLifetime sets the maximum amount of time a connection may be reused.
				
				Expired connections may be closed lazily before reuse.
				
				If d <= 0, connections are not closed due to a connection's age.

			(*DB) SetMaxIdleConns(n int)
				SetMaxIdleConns sets the maximum number of connections in the idle
				connection pool.
				
				If MaxOpenConns is greater than 0 but less than the new MaxIdleConns,
				then the new MaxIdleConns will be reduced to match the MaxOpenConns limit.
				
				If n <= 0, no idle connections are retained.
				
				The default max idle connections is currently 2. This may change in
				a future release.

			(*DB) SetMaxOpenConns(n int)
				SetMaxOpenConns sets the maximum number of open connections to the database.
				
				If MaxIdleConns is greater than 0 and the new MaxOpenConns is less than
				MaxIdleConns, then MaxIdleConns will be reduced to match the new
				MaxOpenConns limit.
				
				If n <= 0, then there is no limit on the number of open connections.
				The default is 0 (unlimited).

			(*DB) Stats() DBStats
				Stats returns database statistics.

		Implements (at least one exported)
			*DB : io.Closer
		As Outputs Of (at least 2)
			func Open(driverName, dataSourceName string) (*DB, error)
			func OpenDB(c driver.Connector) *DB

	 type DBStats (struct)
		DBStats contains database statistics.

		Fields (total 9)
			Idle int
				// The number of idle connections.

			InUse int
				// The number of connections currently in use.

			MaxIdleClosed int64
				// The total number of connections closed due to SetMaxIdleConns.

			MaxIdleTimeClosed int64
				// The total number of connections closed due to SetConnMaxIdleTime.

			MaxLifetimeClosed int64
				// The total number of connections closed due to SetConnMaxLifetime.

			MaxOpenConnections int
				// Maximum number of open connections to the database.

			OpenConnections int
				Pool Status
				// The number of established connections both in use and idle.

			WaitCount int64
				Counters
				// The total number of connections waited for.

			WaitDuration time.Duration
				// The total time blocked waiting for a new connection.

		As Outputs Of (at least one exported)
			func (*DB).Stats() DBStats

	 type IsolationLevel int (basic type)
		IsolationLevel is the transaction isolation level used in [TxOptions].

		Methods (only one)
			( IsolationLevel) String() string
				String returns the name of the transaction isolation level.

		Implements (at least 2)
			 IsolationLevel : expvar.Var
			 IsolationLevel : fmt.Stringer
		As Types Of (total 8)
			const LevelDefault
			const LevelLinearizable
			const LevelReadCommitted
			const LevelReadUncommitted
			const LevelRepeatableRead
			const LevelSerializable
			const LevelSnapshot
			const LevelWriteCommitted

	 type NamedArg (struct)
		A NamedArg is a named argument. NamedArg values may be used as
		arguments to [DB.Query] or [DB.Exec] and bind to the corresponding named
		parameter in the SQL statement.
		
		For a more concise way to create NamedArg values, see
		the [Named] function.

		Fields (total 2)
			Name string
				Name is the name of the parameter placeholder.
				
				If empty, the ordinal position in the argument list will be
				used.
				
				Name must omit any symbol prefix.

			Value any
				Value is the value of the parameter.
				It may be assigned the same value types as the query
				arguments.

		As Outputs Of (at least one exported)
			func Named(name string, value any) NamedArg

	 type Null[T] (struct)

		Type Parameters:
			T: any

		Null represents a value that may be null.
		Null implements the [Scanner] interface so
		it can be used as a scan destination:
		
			var s Null[string]
			err := db.QueryRow("SELECT name FROM foo WHERE id=?", id).Scan(&s)
			...
			if s.Valid {
			   // use s.V
			} else {
			   // NULL value
			}

		Fields (total 2)
			V T
			Valid bool
		Methods (total 2)
			(*Null[T]) Scan(value any) error
			( Null[T]) Value() (driver.Value, error)
		Implements (at least 2)
			*Null : Scanner
			 Null : database/sql/driver.Valuer

	 type NullBool (struct)
		NullBool represents a bool that may be null.
		NullBool implements the [Scanner] interface so
		it can be used as a scan destination, similar to [NullString].

		Fields (total 2)
			Bool bool
			Valid bool
				// Valid is true if Bool is not NULL

		Methods (total 2)
			(*NullBool) Scan(value any) error
				Scan implements the [Scanner] interface.

			( NullBool) Value() (driver.Value, error)
				Value implements the [driver.Valuer] interface.

		Implements (at least 2)
			*NullBool : Scanner
			 NullBool : database/sql/driver.Valuer

	 type NullByte (struct)
		NullByte represents a byte that may be null.
		NullByte implements the [Scanner] interface so
		it can be used as a scan destination, similar to [NullString].

		Fields (total 2)
			Byte byte
			Valid bool
				// Valid is true if Byte is not NULL

		Methods (total 2)
			(*NullByte) Scan(value any) error
				Scan implements the [Scanner] interface.

			( NullByte) Value() (driver.Value, error)
				Value implements the [driver.Valuer] interface.

		Implements (at least 2)
			*NullByte : Scanner
			 NullByte : database/sql/driver.Valuer

	 type NullFloat64 (struct)
		NullFloat64 represents a float64 that may be null.
		NullFloat64 implements the [Scanner] interface so
		it can be used as a scan destination, similar to [NullString].

		Fields (total 2)
			Float64 float64
			Valid bool
				// Valid is true if Float64 is not NULL

		Methods (total 2)
			(*NullFloat64) Scan(value any) error
				Scan implements the [Scanner] interface.

			( NullFloat64) Value() (driver.Value, error)
				Value implements the [driver.Valuer] interface.

		Implements (at least 2)
			*NullFloat64 : Scanner
			 NullFloat64 : database/sql/driver.Valuer

	 type NullInt16 (struct)
		NullInt16 represents an int16 that may be null.
		NullInt16 implements the [Scanner] interface so
		it can be used as a scan destination, similar to [NullString].

		Fields (total 2)
			Int16 int16
			Valid bool
				// Valid is true if Int16 is not NULL

		Methods (total 2)
			(*NullInt16) Scan(value any) error
				Scan implements the [Scanner] interface.

			( NullInt16) Value() (driver.Value, error)
				Value implements the [driver.Valuer] interface.

		Implements (at least 2)
			*NullInt16 : Scanner
			 NullInt16 : database/sql/driver.Valuer

	 type NullInt32 (struct)
		NullInt32 represents an int32 that may be null.
		NullInt32 implements the [Scanner] interface so
		it can be used as a scan destination, similar to [NullString].

		Fields (total 2)
			Int32 int32
			Valid bool
				// Valid is true if Int32 is not NULL

		Methods (total 2)
			(*NullInt32) Scan(value any) error
				Scan implements the [Scanner] interface.

			( NullInt32) Value() (driver.Value, error)
				Value implements the [driver.Valuer] interface.

		Implements (at least 2)
			*NullInt32 : Scanner
			 NullInt32 : database/sql/driver.Valuer

	 type NullInt64 (struct)
		NullInt64 represents an int64 that may be null.
		NullInt64 implements the [Scanner] interface so
		it can be used as a scan destination, similar to [NullString].

		Fields (total 2)
			Int64 int64
			Valid bool
				// Valid is true if Int64 is not NULL

		Methods (total 2)
			(*NullInt64) Scan(value any) error
				Scan implements the [Scanner] interface.

			( NullInt64) Value() (driver.Value, error)
				Value implements the [driver.Valuer] interface.

		Implements (at least 2)
			*NullInt64 : Scanner
			 NullInt64 : database/sql/driver.Valuer

	 type NullString (struct)
		NullString represents a string that may be null.
		NullString implements the [Scanner] interface so
		it can be used as a scan destination:
		
			var s NullString
			err := db.QueryRow("SELECT name FROM foo WHERE id=?", id).Scan(&s)
			...
			if s.Valid {
			   // use s.String
			} else {
			   // NULL value
			}

		Fields (total 2)
			String string
			Valid bool
				// Valid is true if String is not NULL

		Methods (total 2)
			(*NullString) Scan(value any) error
				Scan implements the [Scanner] interface.

			( NullString) Value() (driver.Value, error)
				Value implements the [driver.Valuer] interface.

		Implements (at least 2)
			*NullString : Scanner
			 NullString : database/sql/driver.Valuer

	 type NullTime (struct)
		NullTime represents a [time.Time] that may be null.
		NullTime implements the [Scanner] interface so
		it can be used as a scan destination, similar to [NullString].

		Fields (total 2)
			Time time.Time
			Valid bool
				// Valid is true if Time is not NULL

		Methods (total 2)
			(*NullTime) Scan(value any) error
				Scan implements the [Scanner] interface.

			( NullTime) Value() (driver.Value, error)
				Value implements the [driver.Valuer] interface.

		Implements (at least 2)
			*NullTime : Scanner
			 NullTime : database/sql/driver.Valuer

	 type Out (struct)
		Out may be used to retrieve OUTPUT value parameters from stored procedures.
		
		Not all drivers and databases support OUTPUT value parameters.
		
		Example usage:
		
			var outArg string
			_, err := db.ExecContext(ctx, "ProcName", sql.Named("Arg1", sql.Out{Dest: &outArg}))

		Fields (total 2)
			Dest any
				Dest is a pointer to the value that will be set to the result of the
				stored procedure's OUTPUT parameter.

			In bool
				In is whether the parameter is an INOUT parameter. If so, the input value to the stored
				procedure is the dereferenced value of Dest's pointer, which is then replaced with
				the output value.


	 type RawBytes ([])
		RawBytes is a byte slice that holds a reference to memory owned by
		the database itself. After a [Rows.Scan] into a RawBytes, the slice is only
		valid until the next call to [Rows.Next], [Rows.Scan], or [Rows.Close].

	 type Result (interface)
		A Result summarizes an executed SQL command.

		Methods (total 2)
			( Result) LastInsertId() (int64, error)
				LastInsertId returns the database's auto-generated ID
				after, for example, an INSERT into a table with primary
				key.

			( Result) RowsAffected() (int64, error)
				RowsAffected returns the number of rows affected by the
				query.

		Implemented By (at least 2)
			 database/sql/driver.Result (interface)
			 database/sql/driver.RowsAffected
		Implements (at least one exported)
			 Result : database/sql/driver.Result
		As Outputs Of (at least 7)
			func (*Conn).ExecContext(ctx context.Context, query string, args ...any) (Result, error)
			func (*DB).Exec(query string, args ...any) (Result, error)
			func (*DB).ExecContext(ctx context.Context, query string, args ...any) (Result, error)
			func (*Stmt).Exec(args ...any) (Result, error)
			func (*Stmt).ExecContext(ctx context.Context, args ...any) (Result, error)
			func (*Tx).Exec(query string, args ...any) (Result, error)
			func (*Tx).ExecContext(ctx context.Context, query string, args ...any) (Result, error)

	 type Row (struct)
		Row is the result of calling [DB.QueryRow] to select a single row.

		Methods (total 2)
			(*Row) Err() error
				Err provides a way for wrapping packages to check for
				query errors without calling [Row.Scan].
				Err returns the error, if any, that was encountered while running the query.
				If this error is not nil, this error will also be returned from [Row.Scan].

			(*Row) Scan(dest ...any) error
				Scan copies the columns from the matched row into the values
				pointed at by dest. See the documentation on [Rows.Scan] for details.
				If more than one row matches the query,
				Scan uses the first row and discards the rest. If no row matches
				the query, Scan returns [ErrNoRows].

		As Outputs Of (at least 7)
			func (*Conn).QueryRowContext(ctx context.Context, query string, args ...any) *Row
			func (*DB).QueryRow(query string, args ...any) *Row
			func (*DB).QueryRowContext(ctx context.Context, query string, args ...any) *Row
			func (*Stmt).QueryRow(args ...any) *Row
			func (*Stmt).QueryRowContext(ctx context.Context, args ...any) *Row
			func (*Tx).QueryRow(query string, args ...any) *Row
			func (*Tx).QueryRowContext(ctx context.Context, query string, args ...any) *Row

	 type Rows (struct)
		Rows is the result of a query. Its cursor starts before the first row
		of the result set. Use [Rows.Next] to advance from row to row.

		Methods (total 7)
			(*Rows) Close() error
				Close closes the [Rows], preventing further enumeration. If [Rows.Next] is called
				and returns false and there are no further result sets,
				the [Rows] are closed automatically and it will suffice to check the
				result of [Rows.Err]. Close is idempotent and does not affect the result of [Rows.Err].

			(*Rows) ColumnTypes() ([]*ColumnType, error)
				ColumnTypes returns column information such as column type, length,
				and nullable. Some information may not be available from some drivers.

			(*Rows) Columns() ([]string, error)
				Columns returns the column names.
				Columns returns an error if the rows are closed.

			(*Rows) Err() error
				Err returns the error, if any, that was encountered during iteration.
				Err may be called after an explicit or implicit [Rows.Close].

			(*Rows) Next() bool
				Next prepares the next result row for reading with the [Rows.Scan] method. It
				returns true on success, or false if there is no next result row or an error
				happened while preparing it. [Rows.Err] should be consulted to distinguish between
				the two cases.
				
				Every call to [Rows.Scan], even the first one, must be preceded by a call to [Rows.Next].

			(*Rows) NextResultSet() bool
				NextResultSet prepares the next result set for reading. It reports whether
				there is further result sets, or false if there is no further result set
				or if there is an error advancing to it. The [Rows.Err] method should be consulted
				to distinguish between the two cases.
				
				After calling NextResultSet, the [Rows.Next] method should always be called before
				scanning. If there are further result sets they may not have rows in the result
				set.

			(*Rows) Scan(dest ...any) error
				Scan copies the columns in the current row into the values pointed
				at by dest. The number of values in dest must be the same as the
				number of columns in [Rows].
				
				Scan converts columns read from the database into the following
				common Go types and special types provided by the sql package:
				
					*string
					*[]byte
					*int, *int8, *int16, *int32, *int64
					*uint, *uint8, *uint16, *uint32, *uint64
					*bool
					*float32, *float64
					*interface{}
					*RawBytes
					*Rows (cursor value)
					any type implementing Scanner (see Scanner docs)
				
				In the most simple case, if the type of the value from the source
				column is an integer, bool or string type T and dest is of type *T,
				Scan simply assigns the value through the pointer.
				
				Scan also converts between string and numeric types, as long as no
				information would be lost. While Scan stringifies all numbers
				scanned from numeric database columns into *string, scans into
				numeric types are checked for overflow. For example, a float64 with
				value 300 or a string with value "300" can scan into a uint16, but
				not into a uint8, though float64(255) or "255" can scan into a
				uint8. One exception is that scans of some float64 numbers to
				strings may lose information when stringifying. In general, scan
				floating point columns into *float64.
				
				If a dest argument has type *[]byte, Scan saves in that argument a
				copy of the corresponding data. The copy is owned by the caller and
				can be modified and held indefinitely. The copy can be avoided by
				using an argument of type [*RawBytes] instead; see the documentation
				for [RawBytes] for restrictions on its use.
				
				If an argument has type *interface{}, Scan copies the value
				provided by the underlying driver without conversion. When scanning
				from a source value of type []byte to *interface{}, a copy of the
				slice is made and the caller owns the result.
				
				Source values of type [time.Time] may be scanned into values of type
				*time.Time, *interface{}, *string, or *[]byte. When converting to
				the latter two, [time.RFC3339Nano] is used.
				
				Source values of type bool may be scanned into types *bool,
				*interface{}, *string, *[]byte, or [*RawBytes].
				
				For scanning into *bool, the source may be true, false, 1, 0, or
				string inputs parseable by [strconv.ParseBool].
				
				Scan can also convert a cursor returned from a query, such as
				"select cursor(select * from my_table) from dual", into a
				[*Rows] value that can itself be scanned from. The parent
				select query will close any cursor [*Rows] if the parent [*Rows] is closed.
				
				If any of the first arguments implementing [Scanner] returns an error,
				that error will be wrapped in the returned error.

		Implements (at least one exported)
			*Rows : io.Closer
		As Outputs Of (at least 7)
			func (*Conn).QueryContext(ctx context.Context, query string, args ...any) (*Rows, error)
			func (*DB).Query(query string, args ...any) (*Rows, error)
			func (*DB).QueryContext(ctx context.Context, query string, args ...any) (*Rows, error)
			func (*Stmt).Query(args ...any) (*Rows, error)
			func (*Stmt).QueryContext(ctx context.Context, args ...any) (*Rows, error)
			func (*Tx).Query(query string, args ...any) (*Rows, error)
			func (*Tx).QueryContext(ctx context.Context, query string, args ...any) (*Rows, error)

	 type Scanner (interface)
		Scanner is an interface used by [Rows.Scan].

		Methods (only one)
			( Scanner) Scan(src any) error
				Scan assigns a value from a database driver.
				
				The src value will be of one of the following types:
				
				   int64
				   float64
				   bool
				   []byte
				   string
				   time.Time
				   nil - for NULL values
				
				An error should be returned if the value cannot be stored
				without loss of information.
				
				Reference types such as []byte are only valid until the next call to Scan
				and should not be retained. Their underlying memory is owned by the driver.
				If retention is necessary, copy their values before the next call to Scan.

		Implemented By (at least 9)
			*Null[...]
			*NullBool
			*NullByte
			*NullFloat64
			*NullInt16
			*NullInt32
			*NullInt64
			*NullString
			*NullTime

	 type Stmt (struct)
		Stmt is a prepared statement.
		A Stmt is safe for concurrent use by multiple goroutines.
		
		If a Stmt is prepared on a [Tx] or [Conn], it will be bound to a single
		underlying connection forever. If the [Tx] or [Conn] closes, the Stmt will
		become unusable and all operations will return an error.
		If a Stmt is prepared on a [DB], it will remain usable for the lifetime of the
		[DB]. When the Stmt needs to execute on a new underlying connection, it will
		prepare itself on the new connection automatically.

		Methods (total 7)
			(*Stmt) Close() error
				Close closes the statement.

			(*Stmt) Exec(args ...any) (Result, error)
				Exec executes a prepared statement with the given arguments and
				returns a [Result] summarizing the effect of the statement.
				
				Exec uses [context.Background] internally; to specify the context, use
				[Stmt.ExecContext].

			(*Stmt) ExecContext(ctx context.Context, args ...any) (Result, error)
				ExecContext executes a prepared statement with the given arguments and
				returns a [Result] summarizing the effect of the statement.

			(*Stmt) Query(args ...any) (*Rows, error)
				Query executes a prepared query statement with the given arguments
				and returns the query results as a *Rows.
				
				Query uses [context.Background] internally; to specify the context, use
				[Stmt.QueryContext].

			(*Stmt) QueryContext(ctx context.Context, args ...any) (*Rows, error)
				QueryContext executes a prepared query statement with the given arguments
				and returns the query results as a [*Rows].

			(*Stmt) QueryRow(args ...any) *Row
				QueryRow executes a prepared query statement with the given arguments.
				If an error occurs during the execution of the statement, that error will
				be returned by a call to Scan on the returned [*Row], which is always non-nil.
				If the query selects no rows, the [*Row.Scan] will return [ErrNoRows].
				Otherwise, the [*Row.Scan] scans the first selected row and discards
				the rest.
				
				Example usage:
				
					var name string
					err := nameByUseridStmt.QueryRow(id).Scan(&name)
				
				QueryRow uses [context.Background] internally; to specify the context, use
				[Stmt.QueryRowContext].

			(*Stmt) QueryRowContext(ctx context.Context, args ...any) *Row
				QueryRowContext executes a prepared query statement with the given arguments.
				If an error occurs during the execution of the statement, that error will
				be returned by a call to Scan on the returned [*Row], which is always non-nil.
				If the query selects no rows, the [*Row.Scan] will return [ErrNoRows].
				Otherwise, the [*Row.Scan] scans the first selected row and discards
				the rest.

		Implements (at least one exported)
			*Stmt : io.Closer
		As Outputs Of (at least 7)
			func (*Conn).PrepareContext(ctx context.Context, query string) (*Stmt, error)
			func (*DB).Prepare(query string) (*Stmt, error)
			func (*DB).PrepareContext(ctx context.Context, query string) (*Stmt, error)
			func (*Tx).Prepare(query string) (*Stmt, error)
			func (*Tx).PrepareContext(ctx context.Context, query string) (*Stmt, error)
			func (*Tx).Stmt(stmt *Stmt) *Stmt
			func (*Tx).StmtContext(ctx context.Context, stmt *Stmt) *Stmt
		As Inputs Of (at least 2)
			func (*Tx).Stmt(stmt *Stmt) *Stmt
			func (*Tx).StmtContext(ctx context.Context, stmt *Stmt) *Stmt

	 type Tx (struct)
		Tx is an in-progress database transaction.
		
		A transaction must end with a call to [Tx.Commit] or [Tx.Rollback].
		
		After a call to [Tx.Commit] or [Tx.Rollback], all operations on the
		transaction fail with [ErrTxDone].
		
		The statements prepared for a transaction by calling
		the transaction's [Tx.Prepare] or [Tx.Stmt] methods are closed
		by the call to [Tx.Commit] or [Tx.Rollback].

		Methods (total 12)
			(*Tx) Commit() error
				Commit commits the transaction.

			(*Tx) Exec(query string, args ...any) (Result, error)
				Exec executes a query that doesn't return rows.
				For example: an INSERT and UPDATE.
				
				Exec uses [context.Background] internally; to specify the context, use
				[Tx.ExecContext].

			(*Tx) ExecContext(ctx context.Context, query string, args ...any) (Result, error)
				ExecContext executes a query that doesn't return rows.
				For example: an INSERT and UPDATE.

			(*Tx) Prepare(query string) (*Stmt, error)
				Prepare creates a prepared statement for use within a transaction.
				
				The returned statement operates within the transaction and will be closed
				when the transaction has been committed or rolled back.
				
				To use an existing prepared statement on this transaction, see [Tx.Stmt].
				
				Prepare uses [context.Background] internally; to specify the context, use
				[Tx.PrepareContext].

			(*Tx) PrepareContext(ctx context.Context, query string) (*Stmt, error)
				PrepareContext creates a prepared statement for use within a transaction.
				
				The returned statement operates within the transaction and will be closed
				when the transaction has been committed or rolled back.
				
				To use an existing prepared statement on this transaction, see [Tx.Stmt].
				
				The provided context will be used for the preparation of the context, not
				for the execution of the returned statement. The returned statement
				will run in the transaction context.

			(*Tx) Query(query string, args ...any) (*Rows, error)
				Query executes a query that returns rows, typically a SELECT.
				
				Query uses [context.Background] internally; to specify the context, use
				[Tx.QueryContext].

			(*Tx) QueryContext(ctx context.Context, query string, args ...any) (*Rows, error)
				QueryContext executes a query that returns rows, typically a SELECT.

			(*Tx) QueryRow(query string, args ...any) *Row
				QueryRow executes a query that is expected to return at most one row.
				QueryRow always returns a non-nil value. Errors are deferred until
				[Row]'s Scan method is called.
				If the query selects no rows, the [*Row.Scan] will return [ErrNoRows].
				Otherwise, the [*Row.Scan] scans the first selected row and discards
				the rest.
				
				QueryRow uses [context.Background] internally; to specify the context, use
				[Tx.QueryRowContext].

			(*Tx) QueryRowContext(ctx context.Context, query string, args ...any) *Row
				QueryRowContext executes a query that is expected to return at most one row.
				QueryRowContext always returns a non-nil value. Errors are deferred until
				[Row]'s Scan method is called.
				If the query selects no rows, the [*Row.Scan] will return [ErrNoRows].
				Otherwise, the [*Row.Scan] scans the first selected row and discards
				the rest.

			(*Tx) Rollback() error
				Rollback aborts the transaction.

			(*Tx) Stmt(stmt *Stmt) *Stmt
				Stmt returns a transaction-specific prepared statement from
				an existing statement.
				
				Example:
				
					updateMoney, err := db.Prepare("UPDATE balance SET money=money+? WHERE id=?")
					...
					tx, err := db.Begin()
					...
					res, err := tx.Stmt(updateMoney).Exec(123.45, 98293203)
				
				The returned statement operates within the transaction and will be closed
				when the transaction has been committed or rolled back.
				
				Stmt uses [context.Background] internally; to specify the context, use
				[Tx.StmtContext].

			(*Tx) StmtContext(ctx context.Context, stmt *Stmt) *Stmt
				StmtContext returns a transaction-specific prepared statement from
				an existing statement.
				
				Example:
				
					updateMoney, err := db.Prepare("UPDATE balance SET money=money+? WHERE id=?")
					...
					tx, err := db.Begin()
					...
					res, err := tx.StmtContext(ctx, updateMoney).Exec(123.45, 98293203)
				
				The provided context is used for the preparation of the statement, not for the
				execution of the statement.
				
				The returned statement operates within the transaction and will be closed
				when the transaction has been committed or rolled back.

		Implements (at least one exported)
			*Tx : database/sql/driver.Tx
		As Outputs Of (at least 3)
			func (*Conn).BeginTx(ctx context.Context, opts *TxOptions) (*Tx, error)
			func (*DB).Begin() (*Tx, error)
			func (*DB).BeginTx(ctx context.Context, opts *TxOptions) (*Tx, error)

	 type TxOptions (struct)
		TxOptions holds the transaction options to be used in [DB.BeginTx].

		Fields (total 2)
			Isolation IsolationLevel
				Isolation is the transaction isolation level.
				If zero, the driver or database's default level is used.

			ReadOnly bool
		As Inputs Of (at least 2)
			func (*Conn).BeginTx(ctx context.Context, opts *TxOptions) (*Tx, error)
			func (*DB).BeginTx(ctx context.Context, opts *TxOptions) (*Tx, error)


Package-Level Functions (total 5)

	 func Drivers() []string
		Drivers returns a sorted list of the names of the registered drivers.

	 func Named(name string, value any) NamedArg
		Named provides a more concise way to create [NamedArg] values.
		
		Example usage:
		
			db.ExecContext(ctx, `
			    delete from Invoice
			    where
			        TimeCreated < @end
			        and TimeCreated >= @start;`,
			    sql.Named("start", startTime),
			    sql.Named("end", endTime),
			)

	 func Open(driverName, dataSourceName string) (*DB, error)
		Open opens a database specified by its database driver name and a
		driver-specific data source name, usually consisting of at least a
		database name and connection information.
		
		Most users will open a database via a driver-specific connection
		helper function that returns a [*DB]. No database drivers are included
		in the Go standard library. See https://golang.org/s/sqldrivers for
		a list of third-party drivers.
		
		Open may just validate its arguments without creating a connection
		to the database. To verify that the data source name is valid, call
		[DB.Ping].
		
		The returned [DB] is safe for concurrent use by multiple goroutines
		and maintains its own pool of idle connections. Thus, the Open
		function should be called just once. It is rarely necessary to
		close a [DB].

	 func OpenDB(c driver.Connector) *DB
		OpenDB opens a database using a [driver.Connector], allowing drivers to
		bypass a string based data source name.
		
		Most users will open a database via a driver-specific connection
		helper function that returns a [*DB]. No database drivers are included
		in the Go standard library. See https://golang.org/s/sqldrivers for
		a list of third-party drivers.
		
		OpenDB may just validate its arguments without creating a connection
		to the database. To verify that the data source name is valid, call
		[DB.Ping].
		
		The returned [DB] is safe for concurrent use by multiple goroutines
		and maintains its own pool of idle connections. Thus, the OpenDB
		function should be called just once. It is rarely necessary to
		close a [DB].

	 func Register(name string, driver driver.Driver)
		Register makes a database driver available by the provided name.
		If Register is called twice with the same name or if driver is nil,
		it panics.


Package-Level Variables (total 3)

	  var ErrConnDone error
		ErrConnDone is returned by any operation that is performed on a connection
		that has already been returned to the connection pool.

	  var ErrNoRows error
		ErrNoRows is returned by [Row.Scan] when [DB.QueryRow] doesn't return a
		row. In such a case, QueryRow returns a placeholder [*Row] value that
		defers this error until a Scan.

	  var ErrTxDone error
		ErrTxDone is returned by any operation that is performed on a transaction
		that has already been committed or rolled back.


Package-Level Constants (total 8)

	const LevelDefault IsolationLevel = 0
		Various isolation levels that drivers may support in [DB.BeginTx].
		If a driver does not support a given isolation level an error may be returned.
		
		See https://en.wikipedia.org/wiki/Isolation_(database_systems)#Isolation_levels.

	const LevelLinearizable IsolationLevel = 7
		Various isolation levels that drivers may support in [DB.BeginTx].
		If a driver does not support a given isolation level an error may be returned.
		
		See https://en.wikipedia.org/wiki/Isolation_(database_systems)#Isolation_levels.

	const LevelReadCommitted IsolationLevel = 2
		Various isolation levels that drivers may support in [DB.BeginTx].
		If a driver does not support a given isolation level an error may be returned.
		
		See https://en.wikipedia.org/wiki/Isolation_(database_systems)#Isolation_levels.

	const LevelReadUncommitted IsolationLevel = 1
		Various isolation levels that drivers may support in [DB.BeginTx].
		If a driver does not support a given isolation level an error may be returned.
		
		See https://en.wikipedia.org/wiki/Isolation_(database_systems)#Isolation_levels.

	const LevelRepeatableRead IsolationLevel = 4
		Various isolation levels that drivers may support in [DB.BeginTx].
		If a driver does not support a given isolation level an error may be returned.
		
		See https://en.wikipedia.org/wiki/Isolation_(database_systems)#Isolation_levels.

	const LevelSerializable IsolationLevel = 6
		Various isolation levels that drivers may support in [DB.BeginTx].
		If a driver does not support a given isolation level an error may be returned.
		
		See https://en.wikipedia.org/wiki/Isolation_(database_systems)#Isolation_levels.

	const LevelSnapshot IsolationLevel = 5
		Various isolation levels that drivers may support in [DB.BeginTx].
		If a driver does not support a given isolation level an error may be returned.
		
		See https://en.wikipedia.org/wiki/Isolation_(database_systems)#Isolation_levels.

	const LevelWriteCommitted IsolationLevel = 3
		Various isolation levels that drivers may support in [DB.BeginTx].
		If a driver does not support a given isolation level an error may be returned.
		
		See https://en.wikipedia.org/wiki/Isolation_(database_systems)#Isolation_levels.

The pages are generated with Golds v0.7.0-preview. (GOOS=linux GOARCH=amd64)
Golds is a Go 101 project developed by Tapir Liu.
PR and bug reports are welcome and can be submitted to the issue list.
Please follow @zigo_101 (reachable from the left QR code) to get the latest news of Golds.