sqlbuilder

type Addition interface {
	SqlExpr
	AdditionType() AdditionType
}

type AdditionType int

type Additions []Addition

type Assignment interface {
	SqlExpr
	SqlAssignment()
}

type Assignments []Assignment

type BuildSubQuery func(table Table) SqlExpr

type ColOptionFunc func(c ColumnSetter)

type Column interface {
	SqlExpr
	TableDefinition
	Def() ColumnDef
	Expr(query string, args ...any) *Ex
	Of(table Table) Column
	With(optionFns ...ColOptionFunc) Column
	MatchName(name string) bool
	Name() string
	FieldName() string
}

type ColumnCollection interface {
	SqlExpr

	Of(t Table) ColumnCollection

	F(name string) Column
	Col(name string) Column
	Cols(names ...string) ColumnCollection
	RangeCol(cb func(col Column, idx int) bool)
	Len() int
}

type ColumnCollectionManger interface {
	AddCol(cols ...Column)
}

type ColumnDef struct {
	Type              typex.Type
	DataType          string
	Length            uint64
	Decimal           uint64
	Default           *string
	OnUpdate          *string
	Null              bool
	AutoIncrement     bool
	DeprecatedActions *DeprecatedActions
	Comment           string
	Description       []string
	Relation          []string
}

type ColumnSetter interface {
	SetFieldName(name string)
	SetColumnDef(def ColumnDef)
}

type ColumnValueExpr[T any] func(v Column) SqlExpr

type CombinationAddition interface {
	Addition
	All(stmtSelect SelectStatement) CombinationAddition
	Distinct(stmtSelect SelectStatement) CombinationAddition
}

type ComposedCondition struct {
	SqlConditionMarker
	// contains filtered or unexported fields
}

type Condition struct {
	SqlConditionMarker
	// contains filtered or unexported fields
}

type DataTypeDescriber interface {
	DataType(driverName string) string
}

type DeprecatedActions struct {
	RenameTo string `name:"rename"`
}

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

type FieldValues map[string]interface{}

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

type GroupByAddition interface {
	Addition
	Having(cond SqlExpr) GroupByAddition
}

type IndexDefine struct {
	Kind              string
	Name              string
	Method            string
	ColNameAndOptions []string
}

type IndexOptionFunc func(k *key)

type Indexes map[string][]string

type JoinAddition interface {
	Addition
	On(joinCondition SqlExpr) JoinAddition
	Using(joinColumnList ...Column) JoinAddition
}

type Key interface {
	SqlExpr
	TableDefinition

	Of(table Table) Key

	IsPrimary() bool
	IsUnique() bool
	Name() string
	Columns() ColumnCollection
}

type KeyCollection interface {
	Of(t Table) KeyCollection

	K(name string) Key
	RangeKey(func(k Key, i int) bool)
	Keys(names ...string) KeyCollection
	Len() int
}

type KeyCollectionManager interface {
	AddKey(keys ...Key)
}

type KeyDef interface {
	Method() string
	ColNameAndOptions() []string
}

type LimitAddition interface {
	Addition
	Offset(offset int64) LimitAddition
}

type Model interface {
	TableName() string
}

type NamedArg = sql.NamedArg

type NamedArgSet map[string]any

type OnConflictAddition interface {
	Addition
	DoNothing() OnConflictAddition
	DoUpdateSet(assignments ...Assignment) OnConflictAddition
}

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

type OtherAddition struct {
	SqlExpr
}

type SelectStatement interface {
	SqlExpr
	// contains filtered or unexported methods
}

type SqlCondition interface {
	SqlExpr
	SqlConditionMarker
}

type SqlConditionMarker interface {
	// contains filtered or unexported methods
}

type SqlExpr interface {
	IsNil() bool
	Ex(ctx context.Context) *Ex
}

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

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

type StmtSelect struct {
	SelectStatement
	// contains filtered or unexported fields
}

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

type StructField struct {
	Name       string
	FieldName  string
	Type       typesx.Type
	Field      typesx.StructField
	Tags       map[string]reflectx.StructTag
	Loc        []int
	ModelLoc   []int
	ColumnType ColumnDef
}

type StructFieldValue struct {
	Field     StructField
	TableName string
	Value     reflect.Value
}

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

type Table interface {
	SqlExpr

	// TableName of table
	TableName() string

	// K
	// get index by key name
	// primaryKey could be use `pk`
	K(k string) Key
	// F
	// get col by col name or struct field names
	F(name string) Column

	// Cols
	// get cols by col names or struct field name
	Cols(names ...string) ColumnCollection

	// Keys
	// get indexes by index names
	Keys(names ...string) KeyCollection
}

type TableDefinition interface {
	T() Table
}

type TableExprParse interface {
	Expr(query string, args ...any) *Ex
}

type TableWithTableName interface {
	WithTableName(name string) Table
}

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

type Toggles map[string]bool

type TypedColumn[T any] interface {
	Column

	V(op ColumnValueExpr[T]) SqlExpr
	By(ops ...ColumnValueExpr[T]) Assignment
}

type ValuerExpr interface {
	ValueEx() string
}

type WithColDescriptions interface {
	ColDescriptions() map[string][]string
}

type WithComments interface {
	Comments() map[string]string
}

type WithIndexes interface {
	Indexes() Indexes
}

type WithPrimaryKey interface {
	PrimaryKey() []string
}

type WithRelations interface {
	ColRelations() map[string][]string
}

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

type WithTableDescription interface {
	TableDescription() []string
}

type WithUniqueIndexes interface {
	UniqueIndexes() Indexes
}