database

type BaseConfig struct {
	TrimChar bool `json:"trimChar"`
}

type BaseConfigSetter struct {
	BaseConfig
	// contains filtered or unexported fields
}

type BaseFetchHandler struct {
	// contains filtered or unexported fields
}

type BaseField struct {
	// contains filtered or unexported fields
}

type BaseFieldType struct {
	ColumnType
}

type BaseParam struct {
	// contains filtered or unexported fields
}

type BaseScanner struct {
	// contains filtered or unexported fields
}

type BaseSource struct {
	// contains filtered or unexported fields
}

type BaseTable struct {
	// contains filtered or unexported fields
}

type ColumnType interface {
	Name() string                                   // Column name.
	ScanType() reflect.Type                         // Scanning type.
	Length() (length int64, ok bool)                // Length.
	DecimalSize() (precision, scale int64, ok bool) // Precision.
	Nullable() (nullable, ok bool)                  // Whether it is nullable.
	DatabaseTypeName() string                       // Name of the column's database type.
}

type Config struct {
	Pool PoolConfig `json:"pool"`
}

type ConfigSetter interface {
	SetConfig(conf *config.JSON)
}

type DB struct {
	Source
	// contains filtered or unexported fields
}

type DBWrapper struct {
	*DB
	// contains filtered or unexported fields
}

type Dialect interface {
	Source(*BaseSource) (Source, error) // Data Source
}

type ExecParameter interface {
	ExecParam(string, *sql.TxOptions) (Parameter, bool)
}

type FetchHandler interface {
	OnRecord(element.Record) error
	CreateRecord() (element.Record, error)
}

type Field interface {
	fmt.Stringer

	Index() int                   // Index.
	Name() string                 // Field name.
	Quoted() string               // Referenced field name.
	BindVar(int) string           // Placeholder symbol, starting from 1.
	Select() string               // Selected field name.
	Type() FieldType              // Field type.
	Scanner() Scanner             // Scanner.
	Valuer(element.Column) Valuer // Valuer.
}

type FieldAdder interface {
	AddField(*BaseField) // Add specific column
}

type FieldType interface {
	ColumnType

	IsSupported() bool // Whether it is supported.
}

type FieldsFetcher interface {
	FetchFields(ctx context.Context, db *DB) error // Get specific column
}

type GoType uint8

type GoValuer struct {
	// contains filtered or unexported fields
}

type InsertParam struct {
	*BaseParam
}

type Judger interface {
	schedule.RetryJudger

	ShouldOneByOne(err error) bool
}

type Parameter interface {
	SetTable(Table)                               // Set table or view
	Table() Table                                 // Table or view
	TxOptions() *sql.TxOptions                    // Transaction mode
	Query([]element.Record) (string, error)       // SQL prepare statement
	Agrs([]element.Record) ([]interface{}, error) // Prepare parameters
}

type ParameterOptions struct {
	Table     Table            // Table or view
	Mode      string           // Write mode, e.g., for MySQL
	TxOptions *sql.TxOptions   // Transaction mode
	Records   []element.Record // Write row
}

type PoolConfig struct {
	MaxOpenConns    int            `json:"maxOpenConns"`    // Maximum number of open connections
	MaxIdleConns    int            `json:"maxIdleConns"`    // Maximum number of idle connections
	ConnMaxIdleTime times.Duration `json:"connMaxIdleTime"` // Maximum idle time for connections
	ConnMaxLifetime times.Duration `json:"connMaxLifetime"` // Maximum lifetime for connections
}

type Scanner interface {
	sql.Scanner

	Column() element.Column // Get column data.
}

type Source interface {
	Config() *config.JSON   // Configuration Information
	Key() string            // Typically connection information
	DriverName() string     // Driver Name, used as the first parameter for sql.Open
	ConnectName() string    // Connection Information, used as the second parameter for sql.Open
	Table(*BaseTable) Table // Get Specific Table
}

type Table interface {
	fmt.Stringer

	Quoted() string   // Full name of the referenced table
	Instance() string // Instance name, e.g., for MySQL, it's the database name
	Schema() string   // Schema name, e.g., for Oracle, it's the username (schema name)
	Name() string     // Table name, e.g., for MySQL, it's the table name
	Fields() []Field  // Show all columns
}

type TableQueryParam struct {
	*BaseParam
}

type Valuer interface {
	driver.Valuer
}

type ValuerGoType interface {
	GoType() GoType
}

type WithConnector interface {
	Connector() (driver.Connector, error) // go 1.10 Get Connection
}