sql

type Activator func(dsc DSC) (DB, error)

type Adapter interface {
	// Get driver name
	Driver() string
	//Get database name
	DatabaseName(db DB) (name string, err error)
	// Make connection string for open database
	MakeConnectionString(dsn *DSN) string
	// Check error for deadlock criteria
	IsDeadlock(db DB, err error) bool
	// Acquire local lock
	LockLocal(ctx context.Context, tx Tx, latch string, timeout int) error
	// Release local lock
	UnlockLocal(ctx context.Context, tx Tx, latch string) error
	// Acquire local lock
	LockGlobal(ctx context.Context, tx Tx, latch string, timeout int) error
	// Release local lock
	UnlockGlobal(ctx context.Context, tx Tx, latch string) error
}

type Args map[string]interface{}

type Array []interface{}

type Arrays []Array

type Auditor interface {
	AuditDatabase(Metrics Metrics) error
}

type Composer interface {
	Add(delta int)
	Done()
	Abort() <-chan struct{}
}

type DB interface {
	Scope
	Composer
	Close(ctx context.Context) error
	Driver() driver.Driver
	Ping() error
	Slave() DB
	Master() DB
	Prepare(query string) (Stmt, error)
	PrepareContext(ctx context.Context, query string) (Stmt, error)
	SetMaxIdleConns(n int)
	SetMaxOpenConns(n int)
	SetConnMaxLifetime(d time.Duration)
	IsCluster() bool
	GetMetrics() Metrics
	Audit(auditor interface{}) error
	Interface(detective func(interface{}) interface{}) (interface{}, bool)
	DSC() DSC
	// contains filtered or unexported methods
}

type DSC struct {
	Driver string `json:"Driver"`
	DbId   DbId   `json:"-"`
	DSN    []*DSN `json:"dsn"`
}

type DSN struct {
	Host     string            `json:"host"`     // Host address
	Port     uint16            `json:"port"`     // Host port
	Database string            `json:"database"` // Database name
	Username string            `json:"username"` // User name
	Password string            `json:"password"` // User password
	Params   map[string]string `json:"params"`   // Other parameters
}

type DbId int

type Fetcher interface {
	Scan(dest ...interface{}) error
}

type HalfMetrics struct {
	Count int32 `json:"count"` // Count of executed queries
	Time  int64 `json:"time"`  // Elapsed time (microseconds)
}

type IsolationLevel int

type Metrics struct {
	Query    HalfMetrics `json:"query"`
	Exec     HalfMetrics `json:"exec"`
	Transact HalfMetrics `json:"transact"`
}

type NullBool struct {
	Bool  bool
	Valid bool // Valid is true if Bool is not NULL
}

type NullFloat64 struct {
	Float64 float64
	Valid   bool // Valid is true if Float64 is not NULL
}

type NullInt struct {
	Int   int
	Valid bool // Valid is true if Int is not NULL
}

type NullInt16 struct {
	Int16 int16
	Valid bool // Valid is true if Int16 is not NULL
}

type NullInt32 struct {
	Int32 int32
	Valid bool // Valid is true if Int32 is not NULL
}

type NullInt64 struct {
	Int64 int64
	Valid bool // Valid is true if Int64 is not NULL
}

type NullInt8 struct {
	Int8  int8
	Valid bool // Valid is true if Int8 is not NULL
}

type NullString struct {
	String string
	Valid  bool // Valid is true if String is not NULL
}

type NullTime struct {
	Time  time.Time
	Valid bool // Valid is true if Time is not NULL
}

type NullUint struct {
	Uint  uint
	Valid bool // Valid is true if UInt is not NULL
}

type NullUint16 struct {
	Uint16 uint16
	Valid  bool // Valid is true if UInt16 is not NULL
}

type NullUint32 struct {
	Uint32 uint32
	Valid  bool // Valid is true if UInt32 is not NULL
}

type NullUint64 struct {
	Uint64 uint64
	Valid  bool // Valid is true if UInt64 is not NULL
}

type NullUint8 struct {
	Uint8 uint8
	Valid bool // Valid is true if UInt8 is not NULL
}

type Repository interface {
	// Find actual scope
	Scope(ctx context.Context) Scope
	// Get database
	Database() DB
	// Execute transaction
	Transaction(
		ctx context.Context,
		action func(ctx context.Context) error,
	) error
}

type Result interface {
	LastInsertId() (int64, error)
	RowsAffected() (int64, error)
}

type Row interface {
	Scan(dest ...interface{}) error
}

type Rows interface {
	Err() error
	Next() bool
	Columns() ([]string, error)
	Close() error
	Scan(dest ...interface{}) error
}

type Scanner = sql.Scanner

type Scope interface {
	Begin() (Tx, error)
	BeginTx(ctx context.Context, opts *TxOptions) (Tx, error)
	Exec(query string, args ...interface{}) (Result, error)
	ExecContext(ctx context.Context, query string, args ...interface{}) (Result, error)
	Query(query string, args ...interface{}) (Rows, error)
	QueryContext(ctx context.Context, query string, args ...interface{}) (Rows, error)
	QueryRow(query string, args ...interface{}) Row
	QueryRowContext(ctx context.Context, query string, args ...interface{}) Row
	DbId() DbId
	Adapter() Adapter
}

type Stmt interface {
	Close() error
	Exec(args ...interface{}) (Result, error)
	ExecContext(ctx context.Context, args ...interface{}) (Result, error)
	Query(args ...interface{}) (Rows, error)
	QueryContext(ctx context.Context, args ...interface{}) (Rows, error)
	QueryRow(args ...interface{}) Row
	QueryRowContext(ctx context.Context, args ...interface{}) Row
}

type Tracer interface {
	// Profiler secondary information (skip in production)
	Trace(msg interface{})
}

type Tx interface {
	Scope
	Level() int16
	Commit() error
	Rollback() error
}

type TxOptions = sql.TxOptions