gsd

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

type Builder struct {
	texts.Builder
	Args []interface{}
}

type CallInfo struct {
	SP   string
	Args []interface{}
}

type Column interface {
	Table() Table
	Name() string
	Alias() string
	Field() string
}

type ColumnFilter func(cols []string) []string

type ColumnOptions struct {
	Name          string `json:"name"`
	AutoIncrement bool   `json:"auto"`
	PrimaryKey    bool   `json:"pk"`
	ForeignKey    bool   `json:"fk"`
	Insert        bool   `json:"insert"`
	Update        bool   `json:"update"`
	Select        bool   `json:"select"`
	Where         *struct {
		Column string
		Type   int
		Index  int
	}
	Size int `json:"size"`
}

type Columns []Column

type CountClause interface {
	Join(table interface{}, on CriteriaSet) CountClause
	LeftJoin(t interface{}, on CriteriaSet) CountClause
	RightJoin(t interface{}, on CriteriaSet) CountClause
	FullJoin(t interface{}, on CriteriaSet) CountClause
	Where(f CriteriaSet) CountWhereClause
	CountResultClause
}

type CountGroupByClause interface {
	Having(f CriteriaSet) CountResultClause
	CountResultClause
}

type CountResultClause interface {
	Value() (int, error)
	Scan(dst interface{}) error
}

type CountWhereClause interface {
	GroupBy(cols *Columns) CountGroupByClause
	CountResultClause
}

type Criteria interface {
}

type CriteriaSet interface {
	Empty() bool
}

type DB interface {
	Insert(ctx context.Context, table string) InsertClause
	Create(ctx context.Context, i interface{}, filter ...ColumnFilter) error
	Delete(ctx context.Context, table string) DeleteClause
	Remove(ctx context.Context, i interface{}) (r Result, err error)
	Update(ctx context.Context, table string) UpdateClause
	Modify(ctx context.Context, i interface{}, filter ...ColumnFilter) (r Result, err error)
	Select(ctx context.Context, cols ...string) SelectClause
	//Distinct(ctx context.Context, cols ...string) SelectClause
	Query(ctx context.Context, cols *Columns, distinct ...bool) SelectClause
	Load(ctx context.Context, i interface{}) error
	Count(ctx context.Context, table interface{}) CountClause
	Execute(ctx context.Context, sql string, args ...interface{}) ExecuteClause
	//Call(ctx context.Context, sp string, args ...interface{}) CallClause
	Prepare(ctx context.Context, query string) (*Stmt, error)
	Stmt(name string, b func() string) (*Stmt, error)
	Transact(ctx context.Context, fn func(tx TX) error, opts ...*sql.TxOptions) (err error)
}

type DecValue struct {
	Value any
}

type DeleteClause interface {
	Where(f CriteriaSet) ResultClause
}

type DeleteInfo struct {
	Table string
	Where CriteriaSet
}

type ExecuteClause interface {
	Result() (ExecuteResult, error)
	Value() Value
	Scan(dst ...interface{}) error
	Fill(i interface{}) error
	//One(i interface{}) error
	//All(i interface{}) error
	Reader() (Reader, error)
	For(fn func(r Reader) error) error
}

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

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

type Executor interface {
	Database() string
	Exec(ctx context.Context, query string, args ...interface{}) (sql.Result, error)
	QueryRow(ctx context.Context, query string, args ...interface{}) *sql.Row
	QueryRows(ctx context.Context, query string, args ...interface{}) (*sql.Rows, error)
}

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

type ExprCriteria string

type ExprValue struct {
	Value string
}

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

type Filter func(Executor) Executor

type Filters []Filter

type FromClause interface {
	LimitClause
	SelectResultClause
	Join(table interface{}, on CriteriaSet) JoinClause
	LeftJoin(t interface{}, on CriteriaSet) JoinClause
	RightJoin(t interface{}, on CriteriaSet) JoinClause
	FullJoin(t interface{}, on CriteriaSet) JoinClause
	Where(f CriteriaSet) WhereClause
}

type GroupByClause interface {
	LimitClause
	OrderBy(orders ...*Order) OrderByClause
	Having(f CriteriaSet) HavingClause
	SelectResultClause
}

type HavingClause interface {
	LimitClause
	SelectResultClause
	OrderBy(orders ...*Order) OrderByClause
}

type IncValue struct {
	Value any
}

type InsertClause interface {
	Columns(cols ...string) InsertColumnsClause
}

type InsertColumnsClause interface {
	Values(values ...interface{}) InsertValuesClause
}

type InsertInfo struct {
	Table   string
	Columns []string
	Values  []interface{} // single row or multiple rows
	Filter  ColumnFilter
}

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

type InsertResultClause interface {
	Submit() error
	Result() (InsertResult, error)
}

type InsertValuesClause interface {
	Values(values ...interface{}) InsertValuesClause
	InsertResultClause
}

type JoinClause interface {
	FromClause
}

type JoinCriteriaSet interface {
	CriteriaSet
	Left() CriteriaSet
	Right() CriteriaSet
	Joiner() string
}

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

type LimitClause interface {
	//Lock(Exclusive/Shared) SelectResultClause
	Limit(skip, take int) SelectResultClause
	Page(index, size int) SelectResultClause
}

type Meta struct {
	ID          int32
	Table       string
	Auto        string   // auto increment column
	PrimaryKeys []string // primary key columns
	//ForeignKeys   []string // foreign key columns
	Updates []string // update columns
	Inserts []string // insert columns
	Selects []string // select columns
	Columns []string // all columns, columns = keys + updates = autos + inserts
	Wheres  []*struct {
		Column string
		Type   int
		Index  int
	}
	// contains filtered or unexported fields
}

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

type NotCriteriaSet struct {
	Inner CriteriaSet
}

type NullFloat32 struct {
	Float32 float32
	Valid   bool // Valid is true if Float32 is not NULL
}

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

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

type OneColumnCriteria struct {
	Column
	Type  int
	Value interface{}
}

type Options struct {
	Name         string
	Provider     string
	Driver       string
	Address      string
	MaxOpenConns int
	MaxIdleConns int
	ConnLifetime time.Duration
	Trace        struct {
		Enabled bool
		Time    time.Duration
	}
	Options data.Map
}

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

type Order struct {
	Type OrderType
	Columns
}

type OrderByClause interface {
	LimitClause
	SelectResultClause
}

type OrderType int

type Provider interface {
	BuildInsert(b *Builder, ctx *InsertInfo) (err error)
	BuildDelete(b *Builder, ctx *DeleteInfo) (err error)
	BuildUpdate(b *Builder, ctx *UpdateInfo) (err error)
	BuildSelect(b *Builder, ctx *SelectInfo) (err error)
	BuildCall(b *Builder, ctx *CallInfo) (err error)
}

type ProviderBuilder func(options data.Map) Provider

type Reader interface {
	Scan(dst ...interface{}) error
	Fill(i interface{}) error
	Next() bool
	NextSet() bool
	Close() error
	Err() error
}

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

type ResultClause interface {
	Result() (Result, error)
}

type SelectClause interface {
	From(table interface{}) FromClause
}

type SelectInfo struct {
	Table
	Distinct bool
	Columns
	Where CriteriaSet
	Joins []struct {
		Type string
		Table
		On CriteriaSet
	}
	Groups Columns
	Having CriteriaSet
	Orders []*Order
	Skip   int
	Take   int
	Count  bool // return total count
}

type SelectResultClause interface {
	Value() Value
	//Int() (int, error)
	Scan(dst ...interface{}) error
	Fill(i interface{}) error
	//One(i interface{}) error
	//All(i interface{}) error
	List(i interface{}, total *int) error
	Reader() (Reader, error)
	For(fn func(r Reader) error) error
}

type SetClause interface {
	UpdateClause
	ResultClause
	Where(f CriteriaSet) ResultClause
}

type SimpleColumn string

type SimpleCriteriaSet struct {
	Items []Criteria
}

type Stmt sql.Stmt

type TX interface {
	Insert(ctx context.Context, table string) InsertClause
	Create(ctx context.Context, i interface{}, filter ...ColumnFilter) error
	Delete(ctx context.Context, table string) DeleteClause
	Remove(ctx context.Context, i interface{}) (r Result, err error)
	Update(ctx context.Context, table string) UpdateClause
	Modify(ctx context.Context, i interface{}, filter ...ColumnFilter) (r Result, err error)
	Select(ctx context.Context, cols ...string) SelectClause
	Query(ctx context.Context, cols *Columns, distinct ...bool) SelectClause
	Load(ctx context.Context, i interface{}) error
	Count(ctx context.Context, table interface{}) CountClause
	Execute(ctx context.Context, sql string, args ...interface{}) ExecuteClause
	Prepare(ctx context.Context, query string) (*Stmt, error)
	Stmt(name string, b func() string) (*Stmt, error)
	Commit() error
	Rollback() error
}

type Table interface {
	Name() string
	Alias() string
	Prefix() string
}

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

type TableOptions struct {
	Name            string
	NameStyle       texts.NameStyle
	ColumnNameStyle texts.NameStyle
}

type TwoColumnCriteria struct {
	Left  Column
	Right Column
	Type  int
}

type UpdateClause interface {
	Set(col string, val interface{}) SetClause
	Inc(col string, val interface{}) SetClause
	Dec(col string, val interface{}) SetClause
	Expr(col string, val string) SetClause
}

type UpdateInfo struct {
	Table   string
	Columns []string
	Values  []interface{}
	Where   CriteriaSet
	Filter  ColumnFilter
}

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

type WhereClause interface {
	LimitClause
	//One(i interface{}) error
	SelectResultClause
	GroupBy(cols *Columns) GroupByClause
	OrderBy(orders ...*Order) OrderByClause
}