// Generated by Lisette bindgen
// Source: database/sql/driver (Go stdlib)
// Go: 1.25.5
// Lisette: 0.1.9
import "go:context"
import "go:reflect"
/// IsScanValue is equivalent to [IsValue].
/// It exists for compatibility.
pub fn IsScanValue(v: Unknown) -> bool
/// IsValue reports whether v is a valid [Value] parameter type.
pub fn IsValue(v: Unknown) -> bool
/// 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].
pub interface ColumnConverter {
fn ColumnConverter(idx: int) -> ValueConverter
}
/// Conn is a connection to a database. It is not used concurrently
/// by multiple goroutines.
///
/// Conn is assumed to be stateful.
pub interface Conn {
fn Begin() -> Result<Tx, error>
fn Close() -> Result<(), error>
fn Prepare(query: string) -> Result<Stmt, error>
}
/// ConnBeginTx enhances the [Conn] interface with context and [TxOptions].
pub interface ConnBeginTx {
fn BeginTx(ctx: context.Context, opts: TxOptions) -> Result<Tx, error>
}
/// ConnPrepareContext enhances the [Conn] interface with context.
pub interface ConnPrepareContext {
fn PrepareContext(ctx: context.Context, query: string) -> Result<Stmt, error>
}
/// 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 by
/// [DriverContext]'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.Close]
/// method will call the Close method and return error (if any).
pub interface Connector {
fn Connect(arg0: context.Context) -> Result<Conn, error>
fn Driver() -> Driver
}
/// 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.
pub interface Driver {
fn Open(name: string) -> Result<Conn, 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.
pub interface DriverContext {
fn OpenConnector(name: string) -> Result<Connector, 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.
pub interface Execer {
fn Exec(query: string, args: Slice<Value>) -> Result<Result, error>
}
/// ExecerContext is an optional interface that may be implemented by a [Conn].
///
/// If a [Conn] does not implement [ExecerContext], the [database/sql.DB.Exec]
/// will 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.
pub interface ExecerContext {
fn ExecContext(ctx: context.Context, query: string, args: Slice<NamedValue>) -> Result<Result, error>
}
/// 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.
pub struct IsolationLevel(int)
/// NamedValue holds both the value name and value.
pub struct NamedValue {
pub Name: string,
pub Ordinal: int,
pub Value: Value,
}
/// NamedValueChecker may be optionally implemented by [Conn] or [Stmt]. It provides
/// the driver more control to handle Go and database types beyond the default
/// [Value] 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.
pub interface NamedValueChecker {
fn CheckNamedValue(arg0: Ref<NamedValue>) -> Result<(), error>
}
/// NotNull is a type that implements [ValueConverter] by disallowing nil
/// values but otherwise delegating to another [ValueConverter].
pub struct NotNull {
pub Converter: Option<ValueConverter>,
}
/// Null is a type that implements [ValueConverter] by allowing nil
/// values but otherwise delegating to another [ValueConverter].
pub struct Null {
pub Converter: Option<ValueConverter>,
}
/// Pinger is an optional interface that may be implemented by a [Conn].
///
/// If a [Conn] does not implement Pinger, the [database/sql.DB.Ping] and
/// [database/sql.DB.PingContext] will check if there is at least one [Conn] available.
///
/// If Conn.Ping returns [ErrBadConn], [database/sql.DB.Ping] and [database/sql.DB.PingContext] will remove
/// the [Conn] from pool.
pub interface Pinger {
fn Ping(ctx: context.Context) -> Result<(), 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.
pub interface Queryer {
fn Query(query: string, args: Slice<Value>) -> Result<Rows, error>
}
/// QueryerContext is an optional interface that may be implemented by a [Conn].
///
/// If a [Conn] does not implement QueryerContext, the [database/sql.DB.Query]
/// will 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.
pub interface QueryerContext {
fn QueryContext(ctx: context.Context, query: string, args: Slice<NamedValue>) -> Result<Rows, error>
}
/// Result is the result of a query execution.
pub interface Result {
fn LastInsertId() -> Result<int64, error>
fn RowsAffected() -> Result<int64, error>
}
/// Rows is an iterator over an executed query's results.
pub interface Rows {
fn Close() -> Result<(), error>
fn Columns() -> Slice<string>
fn Next(mut dest: Slice<Value>) -> Result<(), error>
}
/// RowsAffected implements [Result] for an INSERT or UPDATE operation
/// which mutates a number of rows.
pub struct RowsAffected(int64)
/// 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".
pub interface RowsColumnTypeDatabaseTypeName {
fn Close() -> Result<(), error>
fn ColumnTypeDatabaseTypeName(index: int) -> string
fn Columns() -> Slice<string>
fn Next(mut dest: Slice<Value>) -> Result<(), error>
}
/// 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)
pub interface RowsColumnTypeLength {
fn Close() -> Result<(), error>
fn ColumnTypeLength(index: int) -> Option<int64>
fn Columns() -> Slice<string>
fn Next(mut dest: Slice<Value>) -> Result<(), error>
}
/// 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.
pub interface RowsColumnTypeNullable {
fn Close() -> Result<(), error>
fn ColumnTypeNullable(index: int) -> Option<bool>
fn Columns() -> Slice<string>
fn Next(mut dest: Slice<Value>) -> Result<(), error>
}
/// 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)
pub interface RowsColumnTypePrecisionScale {
fn Close() -> Result<(), error>
fn ColumnTypePrecisionScale(index: int) -> Option<(int64, int64)>
fn Columns() -> Slice<string>
fn Next(mut dest: Slice<Value>) -> Result<(), error>
}
/// 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))".
pub interface RowsColumnTypeScanType {
fn Close() -> Result<(), error>
fn ColumnTypeScanType(index: int) -> reflect.Type
fn Columns() -> Slice<string>
fn Next(mut dest: Slice<Value>) -> Result<(), error>
}
/// RowsNextResultSet extends the [Rows] interface by providing a way to signal
/// the driver to advance to the next result set.
pub interface RowsNextResultSet {
fn Close() -> Result<(), error>
fn Columns() -> Slice<string>
fn HasNextResultSet() -> bool
fn Next(mut dest: Slice<Value>) -> Result<(), error>
fn NextResultSet() -> Result<(), error>
}
/// SessionResetter may be implemented by [Conn] to allow drivers to reset the
/// session state associated with the connection and to signal a bad connection.
pub interface SessionResetter {
fn ResetSession(ctx: context.Context) -> Result<(), error>
}
/// Stmt is a prepared statement. It is bound to a [Conn] and not
/// used by multiple goroutines concurrently.
pub interface Stmt {
fn Close() -> Result<(), error>
fn Exec(args: Slice<Value>) -> Result<Result, error>
fn NumInput() -> int
fn Query(args: Slice<Value>) -> Result<Rows, error>
}
/// StmtExecContext enhances the [Stmt] interface by providing Exec with context.
pub interface StmtExecContext {
fn ExecContext(ctx: context.Context, args: Slice<NamedValue>) -> Result<Result, error>
}
/// StmtQueryContext enhances the [Stmt] interface by providing Query with context.
pub interface StmtQueryContext {
fn QueryContext(ctx: context.Context, args: Slice<NamedValue>) -> Result<Rows, error>
}
/// Tx is a transaction.
pub interface Tx {
fn Commit() -> Result<(), error>
fn Rollback() -> Result<(), error>
}
/// TxOptions holds the transaction options.
///
/// This type should be considered identical to [database/sql.TxOptions].
pub struct TxOptions {
pub Isolation: IsolationLevel,
pub ReadOnly: 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.
pub interface Validator {
fn IsValid() -> bool
}
/// Value is a value that drivers must be able to handle.
/// It is either nil, a type handled by a database driver's [NamedValueChecker]
/// interface, 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 [Rows]
/// from the select is closed, the cursor [Rows] will also be closed.
pub struct Value(Unknown)
/// 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:
///
/// - converting from the [Value] types as provided by the sql package
/// into a database table's specific column type and making sure it
/// fits, such as making sure a particular int64 fits in a
/// table's uint16 column.
///
/// - converting a value as given from the database into one of the
/// driver [Value] types.
///
/// - by the [database/sql] package, for converting from a driver's [Value] type
/// to a user's type in a scan.
pub interface ValueConverter {
fn ConvertValue(v: Unknown) -> Result<Value, 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].
pub interface Valuer {
fn Value() -> Result<Value, error>
}
pub var Bool: ()
pub var DefaultParameterConverter: ()
/// ErrBadConn should be returned by a driver to signal to the [database/sql]
/// package 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.
pub var ErrBadConn: error
/// ErrRemoveArgument may be returned from [NamedValueChecker] to instruct the
/// [database/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.
pub var ErrRemoveArgument: error
/// 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.
pub var ErrSkip: error
pub var Int32: ()
pub var ResultNoRows: ()
pub var String: ()
impl NotNull {
fn ConvertValue(self, v: Unknown) -> Result<Value, error>
}
impl Null {
fn ConvertValue(self, v: Unknown) -> Result<Value, error>
}
impl RowsAffected {
fn LastInsertId(self) -> Result<int64, error>
fn RowsAffected(self) -> Result<int64, error>
}