dbal

type Aggregate struct {
	Func    string
	Columns []interface{}
}

type Column struct {
	DBName                   string      `db:"db_name"`
	TableName                string      `db:"table_name"`
	Name                     string      `db:"name"`
	Position                 int         `db:"position"`
	Default                  interface{} `db:"default"`
	DefaultRaw               string      `db:"default_raw"`
	Nullable                 bool        `db:"nullable"`
	IsUnsigned               bool        `db:"unsigned"`
	Type                     string      `db:"type"`
	Length                   *int        `db:"length"`
	OctetLength              *int        `db:"octet_length"`
	Precision                *int        `db:"precision"`
	Scale                    *int        `db:"scale"`
	DateTimePrecision        *int        `db:"datetime_precision"`
	Charset                  *string     `db:"charset"`
	Collation                *string     `db:"collation"`
	Key                      *string     `db:"key"`
	Extra                    *string     `db:"extra"`
	Comment                  *string     `db:"comment"`
	Primary                  bool        `db:"primary"`
	TypeName                 string      `db:"type_name"`
	MaxLength                int
	DefaultLength            int
	MaxPrecision             int
	DefaultPrecision         int
	MaxScale                 int
	DefaultScale             int
	MaxDateTimePrecision     int
	DefaultDateTimePrecision int
	Option                   []string
	Table                    *Table
	Indexes                  []*Index
	Constraint               *Constraint
}

type Command struct {
	Name    string
	Params  []interface{}
	Success func()
	Fail    func()
}

type Config struct {
	Driver   string `json:"driver"`
	DSN      string `json:"dsn"`
	Name     string `json:"name"`
	ReadOnly bool   `json:"readonly,omitempty"`
}

type Connection struct {
	DB      *sqlx.DB
	Config  *Config
	Option  *Option
	Version *Version
}

type Constraint struct {
	SchemaName string
	TableName  string
	ColumnName string
	Type       string
	Args       []string
	Table      *Table
}

type Expression struct {
	Value interface{}
}

type From struct {
	Type   string
	Name   interface{}
	Alias  string
	Offset int
	SQL    string
}

type Grammar interface {
	NewWith(db *sqlx.DB, config *Config, option *Option) (Grammar, error)
	NewWithRead(write *sqlx.DB, writeConfig *Config, read *sqlx.DB, readConfig *Config, option *Option) (Grammar, error)
	Wrap(value interface{}) string
	WrapTable(value interface{}) string
	OnConnected() error
	GetVersion() (*Version, error)
	GetDatabase() string
	GetSchema() string
	GetOperators() []string
	GetTables() ([]string, error)
	TableExists(name string) (bool, error)
	GetTable(name string) (*Table, error)
	CreateTable(table *Table) error
	AlterTable(table *Table) error
	DropTable(name string) error
	DropTableIfExists(name string) error
	RenameTable(old string, new string) error
	GetColumnListing(dbName string, tableName string) ([]*Column, error)
	CompileInsert(query *Query, columns []interface{}, values [][]interface{}) (string, []interface{})
	CompileInsertOrIgnore(query *Query, columns []interface{}, values [][]interface{}) (string, []interface{})
	CompileInsertGetID(query *Query, columns []interface{}, values [][]interface{}, sequence string) (string, []interface{})
	CompileInsertUsing(query *Query, columns []interface{}, sql string) string
	CompileUpsert(query *Query, columns []interface{}, values [][]interface{}, uniqueBy []interface{}, updateValues interface{}) (string, []interface{})
	CompileUpdate(query *Query, values map[string]interface{}) (string, []interface{})
	CompileDelete(query *Query) (string, []interface{})
	CompileTruncate(query *Query) ([]string, [][]interface{})
	CompileSelect(query *Query) string
	CompileSelectOffset(query *Query, offset *int) string
	CompileExists(query *Query) string
	ProcessInsertGetID(sql string, bindings []interface{}, sequence string) (int64, error)
}

type Having struct {
	Type     string
	Column   interface{}
	Operator string
	Value    interface{}
	Boolean  string
	Offset   int
	Values   []interface{}
	Not      bool
	SQL      string
}

type Index struct {
	DBName       string  `db:"db_name"`
	TableName    string  `db:"table_name"`
	ColumnName   string  `db:"column_name"`
	Name         string  `db:"index_name"`
	SEQ          int     `db:"seq_in_index"`
	SeqColumn    int     `db:"seq_in_column"`
	Collation    string  `db:"collation"`
	Nullable     bool    `db:"nullable"`
	Unique       bool    `db:"unique"`
	Primary      bool    `db:"primary"`
	SubPart      int     `db:"sub_part"`
	Type         string  `db:"type"`
	IndexType    string  `db:"index_type"`
	Comment      *string `db:"comment"`
	IndexComment *string `db:"index_comment"`
	Table        *Table
	Columns      []*Column
}

type Join struct {
	Type   string
	Name   interface{}
	Query  *Query
	Alias  string
	SQL    interface{}
	Offset int
}

type Name struct {
	Prefix string
	Name   string
	Alias  string
}

type Option struct {
	Prefix    string `json:"prefix"`
	Collation string `json:"collation"`
	Charset   string `json:"charset"`
}

type Order struct {
	Type      string
	Column    interface{}
	Direction string
	Offset    int
	SQL       string
}

type Primary struct {
	DBName    string `db:"db_name"`
	TableName string `db:"table_name"`
	Name      string `db:"primary_name"`
	Table     *Table
	Columns   []*Column
}

type Query struct {
	UseWriteConnection bool
	Lock               interface{}
	From               From
	Columns            []interface{}
	Aggregate          Aggregate
	Wheres             []Where
	Joins              []Join
	Unions             []Union
	UnionLimit         int
	UnionOffset        int
	UnionOrders        []Order
	Orders             []Order
	Limit              int
	Offset             int
	Groups             []interface{}
	Havings            []Having
	Bindings           map[string][]interface{}
	Distinct           bool
	DistinctColumns    []interface{}
	IsJoinClause       bool
	BindingOffset      int
	SQL                string
}

type Quoter interface {
	Bind(db *sqlx.DB, prefix string, dbRead ...*sqlx.DB) Quoter
	ID(value string) string
	VAL(value interface{}) string
	Wrap(value interface{}) string
	WrapTable(value interface{}) string
	WrapUnion(sql string) string
	IsExpression(value interface{}) bool
	Parameter(value interface{}, num int) string
	Parameterize(values []interface{}, offset int) string
	Columnize(columns []interface{}) string
}

type Select struct {
	Type   string
	Name   interface{}
	Alias  string
	Offset int
	SQL    string
}

type Table struct {
	DBName        string    `db:"db_name"`
	SchemaName    string    `db:"schema_name"`
	TableName     string    `db:"table_name"`
	Comment       string    `db:"table_comment"`
	Type          string    `db:"table_type"`
	Engine        string    `db:"engine"`
	CreateTime    time.Time `db:"create_time"`
	CreateOptions string    `db:"create_options"`
	Collation     string    `db:"collation"`
	Charset       string    `db:"charset"`
	Rows          int       `db:"table_rows"`
	RowLength     int       `db:"avg_row_length"`
	IndexLength   int       `db:"index_length"`
	AutoIncrement int       `db:"auto_increment"`
	Primary       *Primary
	ColumnMap     map[string]*Column
	IndexMap      map[string]*Index
	Columns       []*Column
	Indexes       []*Index
	Commands      []*Command
}

type Union struct {
	All   bool
	Query *Query
}

type Version struct {
	Driver string
	semver.Version
}

type Where struct {
	Type     string
	Column   interface{}
	First    interface{}
	Second   interface{}
	SQL      string
	Operator string
	Boolean  string
	Wheres   []Where
	Query    *Query
	Value    interface{}
	Values   []interface{}
	ValuesIn interface{}
	Not      bool
	Offset   int
}