driver package - database/sql/driver - Go Packages (original) (raw)

Package driver defines interfaces to be implemented by database drivers as used by package sql.

Most code should use the database/sql package.

The driver interface has evolved over time. Drivers should implementConnector and DriverContext interfaces. The Connector.Connect and Driver.Open methods should never return ErrBadConn.ErrBadConn should only be returned from Validator, SessionResetter, or a query method if the connection is already in an invalid (e.g. closed) state.

All Conn implementations should implement the following interfaces:Pinger, SessionResetter, and Validator.

If named parameters or context are supported, the driver's Conn should implement:ExecerContext, QueryerContext, ConnPrepareContext, and ConnBeginTx.

To support custom data types, implement NamedValueChecker. NamedValueCheckeralso allows queries to accept per-query options as a parameter by returningErrRemoveArgument from CheckNamedValue.

If multiple result sets are supported, Rows should implement RowsNextResultSet. If the driver knows how to describe the types present in the returned result it should implement the following interfaces: RowsColumnTypeScanType,RowsColumnTypeDatabaseTypeName, RowsColumnTypeLength, RowsColumnTypeNullable, and RowsColumnTypePrecisionScale. A given row value may also return a Rowstype, which may represent a database cursor value.

If a Conn implements Validator, then the IsValid method is called before returning the connection to the connection pool. If an entry in the connection pool implements SessionResetter, then ResetSession is called before reusing the connection for another query. If a connection is never returned to the connection pool but is immediately reused, then ResetSession is called prior to reuse but IsValid is not called.

This section is empty.

Bool is a ValueConverter that converts input values to bool.

The conversion rules are:

View Source

var DefaultParameterConverter defaultConverter

DefaultParameterConverter is the default implementation ofValueConverter that's used when a Stmt doesn't implementColumnConverter.

DefaultParameterConverter returns its argument directly if IsValue(arg). Otherwise, if the argument implements Valuer, its Value method is used to return a Value. As a fallback, the provided argument's underlying type is used to convert it to a Value: underlying integer types are converted to int64, floats to float64, bool, string, and []byte to themselves. If the argument is a nil pointer, defaultConverter.ConvertValue returns a nil Value. If the argument is a non-nil pointer, it is dereferenced and defaultConverter.ConvertValue is called recursively. Other types are an error.

ErrBadConn should be returned by a driver to signal to the database/sqlpackage that a driver.Conn is in a bad state (such as the server having earlier closed the connection) and the database/sql package should retry on a new connection.

To prevent duplicate operations, ErrBadConn should NOT be returned if there's a possibility that the database server might have performed the operation. Even if the server sends back an error, you shouldn't return ErrBadConn.

Errors will be checked using errors.Is. An error may wrap ErrBadConn or implement the Is(error) bool method.

ErrRemoveArgument may be returned from NamedValueChecker to instruct thedatabase/sql package to not pass the argument to the driver query interface. Return when accepting query specific options or structures that aren't SQL query arguments.

ErrSkip may be returned by some optional interfaces' methods to indicate at runtime that the fast path is unavailable and the sql package should continue as if the optional interface was not implemented. ErrSkip is only supported where explicitly documented.

Int32 is a ValueConverter that converts input values to int64, respecting the limits of an int32 value.

ResultNoRows is a pre-defined Result for drivers to return when a DDL command (such as a CREATE TABLE) succeeds. It returns an error for both LastInsertId and RowsAffected.

String is a ValueConverter that converts its input to a string. If the value is already a string or []byte, it's unchanged. If the value is of another type, conversion to string is done with fmt.Sprintf("%v", v).

IsScanValue is equivalent to IsValue. It exists for compatibility.

IsValue reports whether v is a valid Value parameter type.

type ColumnConverter deprecated

type ColumnConverter interface {

ColumnConverter(idx [int](/builtin#int)) [ValueConverter](#ValueConverter)

}

ColumnConverter may be optionally implemented by Stmt if the statement is aware of its own columns' types and can convert from any type to a driver Value.

Deprecated: Drivers should implement NamedValueChecker.

Conn is a connection to a database. It is not used concurrently by multiple goroutines.

Conn is assumed to be stateful.

ConnBeginTx enhances the Conn interface with context and TxOptions.

ConnPrepareContext enhances the Conn interface with context.

A Connector represents a driver in a fixed configuration and can create any number of equivalent Conns for use by multiple goroutines.

A Connector can be passed to database/sql.OpenDB, to allow drivers to implement their own database/sql.DB constructors, or returned byDriverContext's OpenConnector method, to allow drivers access to context and to avoid repeated parsing of driver configuration.

If a Connector implements io.Closer, the database/sql.DB.Closemethod will call the Close method and return error (if any).

Driver is the interface that must be implemented by a database driver.

Database drivers may implement DriverContext for access to contexts and to parse the name only once for a pool of connections, instead of once per connection.

type DriverContext interface {

OpenConnector(name [string](/builtin#string)) ([Connector](#Connector), [error](/builtin#error))

}

If a Driver implements DriverContext, then database/sql.DB will call OpenConnector to obtain a Connector and then invoke that Connector's Connect method to obtain each needed connection, instead of invoking the Driver's Open method for each connection. The two-step sequence allows drivers to parse the name just once and also provides access to per-Conn contexts.

type Execer interface { Exec(query string, args []Value) (Result, error) }

Execer is an optional interface that may be implemented by a Conn.

If a Conn implements neither ExecerContext nor Execer, the database/sql.DB.Exec will first prepare a query, execute the statement, and then close the statement.

Exec may return ErrSkip.

Deprecated: Drivers should implement ExecerContext instead.

ExecerContext is an optional interface that may be implemented by a Conn.

If a Conn does not implement ExecerContext, the database/sql.DB.Execwill fall back to Execer; if the Conn does not implement Execer either,database/sql.DB.Exec will first prepare a query, execute the statement, and then close the statement.

ExecContext may return ErrSkip.

ExecContext must honor the context timeout and return when the context is canceled.

IsolationLevel is the transaction isolation level stored in TxOptions.

This type should be considered identical to database/sql.IsolationLevel along with any values defined on it.

type NamedValue struct {

Name [string](/builtin#string)


Ordinal [int](/builtin#int)


Value [Value](#Value)

}

NamedValue holds both the value name and value.

type NamedValueChecker interface {

CheckNamedValue(*[NamedValue](#NamedValue)) [error](/builtin#error)

}

NamedValueChecker may be optionally implemented by Conn or Stmt. It provides the driver more control to handle Go and database types beyond the defaultValue types allowed.

The database/sql package checks for value checkers in the following order, stopping at the first found match: Stmt.NamedValueChecker, Conn.NamedValueChecker, Stmt.ColumnConverter, DefaultParameterConverter.

If CheckNamedValue returns ErrRemoveArgument, the NamedValue will not be included in the final query arguments. This may be used to pass special options to the query itself.

If ErrSkip is returned the column converter error checking path is used for the argument. Drivers may wish to return ErrSkip after they have exhausted their own special cases.

type NotNull struct { Converter ValueConverter }

NotNull is a type that implements ValueConverter by disallowing nil values but otherwise delegating to another ValueConverter.

type Null struct { Converter ValueConverter }

Null is a type that implements ValueConverter by allowing nil values but otherwise delegating to another ValueConverter.

type Queryer interface { Query(query string, args []Value) (Rows, error) }

Queryer is an optional interface that may be implemented by a Conn.

If a Conn implements neither QueryerContext nor Queryer, the database/sql.DB.Query will first prepare a query, execute the statement, and then close the statement.

Query may return ErrSkip.

Deprecated: Drivers should implement QueryerContext instead.

QueryerContext is an optional interface that may be implemented by a Conn.

If a Conn does not implement QueryerContext, the database/sql.DB.Querywill fall back to Queryer; if the Conn does not implement Queryer either,database/sql.DB.Query will first prepare a query, execute the statement, and then close the statement.

QueryContext may return ErrSkip.

QueryContext must honor the context timeout and return when the context is canceled.

Result is the result of a query execution.

Rows is an iterator over an executed query's results.

RowsAffected implements Result for an INSERT or UPDATE operation which mutates a number of rows.

type RowsColumnTypeDatabaseTypeName added in go1.8

type RowsColumnTypeDatabaseTypeName interface { Rows ColumnTypeDatabaseTypeName(index int) string }

RowsColumnTypeDatabaseTypeName may be implemented by Rows. It should return the database system type name without the length. Type names should be uppercase. Examples of returned types: "VARCHAR", "NVARCHAR", "VARCHAR2", "CHAR", "TEXT", "DECIMAL", "SMALLINT", "INT", "BIGINT", "BOOL", "[]BIGINT", "JSONB", "XML", "TIMESTAMP".

type RowsColumnTypeLength added in go1.8

type RowsColumnTypeLength interface { Rows ColumnTypeLength(index int) (length int64, ok bool) }

RowsColumnTypeLength may be implemented by Rows. It should return the length of the column type if the column is a variable length type. If the column is not a variable length type ok should return false. If length is not limited other than system limits, it should return math.MaxInt64. The following are examples of returned values for various types:

TEXT (math.MaxInt64, true) varchar(10) (10, true) nvarchar(10) (10, true) decimal (0, false) int (0, false) bytea(30) (30, true)

type RowsColumnTypeNullable added in go1.8

type RowsColumnTypeNullable interface { Rows ColumnTypeNullable(index int) (nullable, ok bool) }

RowsColumnTypeNullable may be implemented by Rows. The nullable value should be true if it is known the column may be null, or false if the column is known to be not nullable. If the column nullability is unknown, ok should be false.

type RowsColumnTypePrecisionScale added in go1.8

type RowsColumnTypePrecisionScale interface { Rows ColumnTypePrecisionScale(index int) (precision, scale int64, ok bool) }

RowsColumnTypePrecisionScale may be implemented by Rows. It should return the precision and scale for decimal types. If not applicable, ok should be false. The following are examples of returned values for various types:

decimal(38, 4) (38, 4, true) int (0, 0, false) decimal (math.MaxInt64, math.MaxInt64, true)

type RowsColumnTypeScanType added in go1.8

type RowsColumnTypeScanType interface { Rows ColumnTypeScanType(index int) reflect.Type }

RowsColumnTypeScanType may be implemented by Rows. It should return the value type that can be used to scan types into. For example, the database column type "bigint" this should return "reflect.TypeOf(int64(0))".

type RowsNextResultSet interface { Rows

HasNextResultSet() [bool](/builtin#bool)


NextResultSet() [error](/builtin#error)

}

RowsNextResultSet extends the Rows interface by providing a way to signal the driver to advance to the next result set.

SessionResetter may be implemented by Conn to allow drivers to reset the session state associated with the connection and to signal a bad connection.

type Stmt interface {

Close() [error](/builtin#error)


NumInput() [int](/builtin#int)


Exec(args [][Value](#Value)) ([Result](#Result), [error](/builtin#error))


Query(args [][Value](#Value)) ([Rows](#Rows), [error](/builtin#error))

}

Stmt is a prepared statement. It is bound to a Conn and not used by multiple goroutines concurrently.

StmtExecContext enhances the Stmt interface by providing Exec with context.

StmtQueryContext enhances the Stmt interface by providing Query with context.

type Tx interface { Commit() error Rollback() error }

Tx is a transaction.

type TxOptions struct { Isolation IsolationLevel ReadOnly bool }

TxOptions holds the transaction options.

This type should be considered identical to database/sql.TxOptions.

type Validator interface {

IsValid() [bool](/builtin#bool)

}

Validator may be implemented by Conn to allow drivers to signal if a connection is valid or if it should be discarded.

If implemented, drivers may return the underlying error from queries, even if the connection should be discarded by the connection pool.

Value is a value that drivers must be able to handle. It is either nil, a type handled by a database driver's NamedValueCheckerinterface, or an instance of one of these types:

int64 float64 bool []byte string time.Time

If the driver supports cursors, a returned Value may also implement the Rows interface in this package. This is used, for example, when a user selects a cursor such as "select cursor(select * from my_table) from dual". If the Rowsfrom the select is closed, the cursor Rows will also be closed.

type ValueConverter interface {

ConvertValue(v [any](/builtin#any)) ([Value](#Value), [error](/builtin#error))

}

ValueConverter is the interface providing the ConvertValue method.

Various implementations of ValueConverter are provided by the driver package to provide consistent implementations of conversions between drivers. The ValueConverters have several uses:

type Valuer interface {

Value() ([Value](#Value), [error](/builtin#error))

}

Valuer is the interface providing the Value method.

Errors returned by the Value method are wrapped by the database/sql package. This allows callers to use errors.Is for precise error handling after operations like database/sql.Query, database/sql.Exec, or database/sql.QueryRow.

Types implementing Valuer interface are able to convert themselves to a driver Value.