dbal

type Aggregate struct {
	Func    string        // AVG, COUNT, MIN, MAX, SUM
	Columns []interface{} // The columns for Aggregate
}

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        // The command name
	Params  []interface{} // The command parameters
	Success func()        // Success callback function
	Fail    func()        // Fail callback function
}

type Config struct {
	Driver   string `json:"driver"`        // The driver name. mysql,pgsql,sqlite3,oci,sqlsrv
	DSN      string `json:"dsn,omitempty"` // The driver wrapper. sqlite:///:memory:, mysql://localhost:4486/foo?charset=UTF8
	Name     string `json:"name,omitempty"`
	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

	// Grammar for migrating
	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)

	// Grammar for querying
	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      // inner, left, right, cross
	Name   interface{} // The table the join clause is joining to.
	Query  *Query
	Alias  string
	SQL    interface{}
	Offset int
}

type Name struct {
	Prefix string
	Name   string
	Alias  string
}

type Option struct {
	Prefix    string `json:"prefix,omitempty"` // Table prifix
	Collation string `json:"collation,omitempty"`
	Charset   string `json:"charset,omitempty"`
}

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                     // Whether to use write connection for the select. default is false
	Lock               interface{}              //  Indicates whether row locking is being used.
	From               From                     // The table which the query is targeting.
	Columns            []interface{}            // The columns that should be returned. (Name or Expression)
	Aggregate          Aggregate                // An aggregate function and column to be run.
	Wheres             []Where                  // The where constraints for the query.
	Joins              []Join                   // The table joins for the query.
	Unions             []Union                  // The query union statements.
	UnionLimit         int                      // The maximum number of union records to return.
	UnionOffset        int                      // The number of union records to skip.
	UnionOrders        []Order                  // The orderings for the union query.
	Orders             []Order                  // The orderings for the query.
	Limit              int                      // The maximum number of records to return.
	Offset             int                      // The number of records to skip.
	Groups             []interface{}            // The groupings for the query.
	Havings            []Having                 // The having constraints for the query.
	Bindings           map[string][]interface{} // The current query value bindings.
	Distinct           bool                     // Indicates if the query returns distinct results. Occasionally contains the columns that should be distinct. default is false
	DistinctColumns    []interface{}            // Indicates if the query returns distinct results. Occasionally contains the columns that should be distinct.
	IsJoinClause       bool                     // Determine if the query is a join clause.
	BindingOffset      int                      // The Binding offset before select
	SQL                string                   // The SQL STMT
}

type Quoter interface {
	Bind(db *sqlx.DB, prefix string, dbRead ...*sqlx.DB) Quoter
	ID(value string) string
	VAL(value interface{}) string // operates on both string and []byte and int or other types.
	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 // Union all
	Query *Query
}

type Version struct {
	Driver string
	semver.Version
}

type Where struct {
	Type     string // basic, nested, sub, null, notnull ...
	Column   interface{}
	First    interface{} // for comparing the two columns
	Second   interface{} // for comparing the two columns
	SQL      string
	Operator string
	Boolean  string
	Wheres   []Where
	Query    *Query
	Value    interface{}
	Values   []interface{}
	ValuesIn interface{}
	Not      bool
	Offset   int
}