hey

type AdjustColumnAnyValue func(columnTypes []*sql.ColumnType, results []map[string]any) error

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

type CacheMaker interface {
	// GetCacheKey Use prepare and args to calculate the hash value as the cache key.
	GetCacheKey() (string, error)

	// UseCacheKey Custom build cache key.
	UseCacheKey(cacheKey func(maker Maker) (string, error)) CacheMaker

	// Reset For reset maker and it's related property values.
	Reset(maker ...Maker) CacheMaker

	// Get For get value from cache.
	Get() (value []byte, exists bool, err error)

	// Set For set value to cache.
	Set(value []byte, duration ...time.Duration) error

	// Del Delete data in the cache based on cache key.
	Del() error

	// Exists Check whether the cache key exists.
	Exists() (exists bool, err error)

	// GetUnmarshal Query data and unmarshal data.
	GetUnmarshal(value any) (exists bool, err error)

	// MarshalSet Marshal data and set data.
	MarshalSet(value any, duration ...time.Duration) error

	// GetString Get string type value.
	GetString() (string, bool, error)

	// SetString Set string type value.
	SetString(value string, duration ...time.Duration) error

	// GetFloat Get float64 type value.
	GetFloat() (float64, bool, error)

	// SetFloat Set float64 type value.
	SetFloat(value float64, duration ...time.Duration) error

	// GetInt Get int64 type value.
	GetInt() (int64, bool, error)

	// SetInt Set int64 type value.
	SetInt(value int64, duration ...time.Duration) error

	// GetBool Get boolean type value.
	GetBool() (bool, bool, error)

	// SetBool Set boolean type value.
	SetBool(value bool, duration ...time.Duration) error
}

type Cacher interface {
	// Key Customize cache key processing before reading and writing cache.
	Key(key string) string

	// Get Reading data from the cache.
	Get(key string) (value []byte, exists bool, err error)

	// Set Writing data to the cache.
	Set(key string, value []byte, duration ...time.Duration) error

	// Del Deleting data from the cache.
	Del(key string) error

	// Exists Check if a certain data exists in the cache.
	Exists(key string) (exists bool, err error)

	// Marshal Serialize cache data.
	Marshal(v any) ([]byte, error)

	// Unmarshal Deserialize cache data.
	Unmarshal(data []byte, v any) error
}

type Cfg struct {
	// Debug For debug output SQL script.
	Debug DebugMaker

	// MapScan Custom MapScan.
	MapScan MapScanner

	// Manual For handling different types of databases.
	Manual *Manual

	// Scan For scanning data into structure.
	Scan func(rows *sql.Rows, result any, tag string) error

	// TransactionOptions Start transaction.
	TransactionOptions *sql.TxOptions

	// ScanTag Scan data to tag mapping on structure.
	ScanTag string

	// TableMethodName Custom method name to get table name.
	TableMethodName string

	// TransactionMaxDuration Maximum transaction execution time.
	TransactionMaxDuration time.Duration

	// WarnDuration SQL execution time warning threshold.
	WarnDuration time.Duration

	// DeleteMustUseWhere Deletion of data must be filtered using conditions.
	DeleteMustUseWhere bool

	// UpdateMustUseWhere Updated data must be filtered using conditions.
	UpdateMustUseWhere bool
}

type DatabaseReader interface {
	// Read Get an object for read.
	Read() *Way
}

type DebugMaker interface {
	// Debug Output SQL script to the specified output stream.
	// Warning: Binary byte slice will be converted to hexadecimal strings.
	Debug(maker Maker) DebugMaker

	GetLogger() *logger.Logger

	SetLogger(log *logger.Logger) DebugMaker
}

type Err string

type Filter interface {
	Maker

	// ToEmpty Clear the existing conditional filtering of the current object.
	ToEmpty() Filter

	// Num Number of conditions used.
	Num() int

	// IsEmpty Is the current object an empty object?
	IsEmpty() bool

	// Not Negate the result of the current conditional filter object. Multiple negations are allowed.
	Not() Filter

	// And Use logical operator `AND` to combine custom conditions.
	And(script *SQL) Filter

	// Or Use logical operator `OR` to combine custom conditions.
	Or(script *SQL) Filter

	// Group Add a new condition group, which is connected by the `AND` logical operator by default.
	Group(group func(g Filter)) Filter

	// OrGroup Add a new condition group, which is connected by the `OR` logical operator by default.
	OrGroup(group func(g Filter)) Filter

	// Use Implement import a set of conditional filter objects into the current object.
	Use(filters ...Filter) Filter

	// New Create a new conditional filter object based on a set of conditional filter objects.
	New(filters ...Filter) Filter

	// Equal Implement conditional filtering: column = value .
	Equal(column any, value any, null ...bool) Filter

	// LessThan Implement conditional filtering: column < value .
	LessThan(column any, value any) Filter

	// LessThanEqual Implement conditional filtering: column <= value .
	LessThanEqual(column any, value any) Filter

	// MoreThan Implement conditional filtering: column > value.
	MoreThan(column any, value any) Filter

	// MoreThanEqual Implement conditional filtering: column >= value .
	MoreThanEqual(column any, value any) Filter

	// Between Implement conditional filtering: column BETWEEN value1 AND value2 .
	Between(column any, start any, end any) Filter

	// In Implement conditional filtering: column IN ( value1, value2, value3... ) || column IN ( subquery ) .
	In(column any, values ...any) Filter

	// InGroup Implement conditional filtering: ( column1, column2, column3... ) IN ( ( value1, value2, value3... ), ( value21, value22, value23... )... ) || ( column1, column2, column3... ) IN ( subquery ) .
	InGroup(columns any, values any) Filter

	// Exists Implement conditional filtering: EXISTS (subquery) .
	Exists(subquery Maker) Filter

	// Like Implement conditional filtering: column LIKE value.
	Like(column any, value any) Filter

	// IsNull Implement conditional filtering: column IS NULL .
	IsNull(column any) Filter

	// NotEqual Implement conditional filtering: column <> value .
	NotEqual(column any, value any, null ...bool) Filter

	// NotBetween Implement conditional filtering: column NOT BETWEEN value1 AND value2 .
	NotBetween(column any, start any, end any) Filter

	// NotIn Implement conditional filtering: column NOT IN ( value1, value2, value3... ) .
	NotIn(column any, values ...any) Filter

	// NotInGroup Implement conditional filtering: ( column1, column2, column3... ) NOT IN ( ( value1, value2, value3... ), ( value21, value22, value23... )... ) || ( column1, column2, column3... ) NOT IN ( subquery ) .
	NotInGroup(columns any, values any) Filter

	// NotExists Implement conditional filtering: NOT EXISTS (subquery) .
	NotExists(subquery Maker) Filter

	// NotLike Implement conditional filtering: column NOT LIKE value .
	NotLike(column any, value any) Filter

	// IsNotNull Implement conditional filtering: column IS NOT NULL .
	IsNotNull(column any) Filter

	// AllQuantifier Implement conditional filtering: column {=||<>||>||>=||<||<=} ALL ( subquery ) .
	AllQuantifier(fc func(q Quantifier)) Filter

	// AnyQuantifier Implement conditional filtering: column {=||<>||>||>=||<||<=} ANY ( subquery ) .
	AnyQuantifier(fc func(q Quantifier)) Filter

	// GetReplacer For get *Way.
	GetReplacer() Replacer

	// SetReplacer For set *Way.
	SetReplacer(replacer Replacer) Filter

	// CompareEqual Implement conditional filtering: script1 = script2 .
	CompareEqual(column1 any, column2 any) Filter

	// CompareNotEqual Implement conditional filtering: script1 <> script2 .
	CompareNotEqual(column1 any, column2 any) Filter

	// CompareMoreThan Implement conditional filtering: script1 > script2 .
	CompareMoreThan(column1 any, column2 any) Filter

	// CompareMoreThanEqual Implement conditional filtering: script1 >= script2 .
	CompareMoreThanEqual(column1 any, column2 any) Filter

	// CompareLessThan Implement conditional filtering: script1 < script2.
	CompareLessThan(column1 any, column2 any) Filter

	// CompareLessThanEqual Implement conditional filtering: script1 <= script2 .
	CompareLessThanEqual(column1 any, column2 any) Filter
}

type Limiter interface {
	GetLimit() int64

	GetOffset() int64
}

type Maker interface {
	// ToSQL Construct SQL statements that may contain parameters, the return value cannot be nil.
	ToSQL() *SQL
}

type Manual struct {
	// Prepare to adjust the SQL statement format to meet the current database SQL statement format.
	Prepare func(prepare string) string

	// Replacer SQL Identifier Replacer.
	Replacer Replacer
}

type MapScanner interface {
	// AdjustColumnAnyValue Customize the default method for adjusting column values.
	AdjustColumnAnyValue(adjust AdjustColumnAnyValue) MapScanner

	// Scan Scanning the query results into []map[string]any.
	// You can define a column value adjustment method with a higher priority
	// than the default through the adjusts parameter.
	Scan(rows *sql.Rows, adjusts ...AdjustColumnAnyValue) ([]map[string]any, error)
}

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

type MyContext string

type MyDelete interface {
	// AfterDelete Set post-delete data hook.
	AfterDelete(fc func(ctx context.Context) (context.Context, error))

	// AfterDeleteValue Get post-delete data hook.
	AfterDeleteValue() func(ctx context.Context) (context.Context, error)

	// BeforeDelete Set pre-delete data hook.
	BeforeDelete(fc func(ctx context.Context) (context.Context, error))

	// BeforeDeleteValue Get pre-delete data hook.
	BeforeDeleteValue() func(ctx context.Context) (context.Context, error)

	// DeleteFilter Custom delete logic Filter.
	DeleteFilter(fc func(f Filter))

	// DeleteFilterValue Custom delete logic Filter value.
	DeleteFilterValue() func(f Filter)

	// ResetDelete Reset the default Delete method.
	ResetDelete(fc func(ctx context.Context, where Filter) (affectedRows int64, err error))

	// Delete Physically delete data.
	Delete(ctx context.Context, where Filter) (affectedRows int64, err error)

	// DeleteById Physically delete data.
	DeleteById(ctx context.Context, ids any) (affectedRows int64, err error)
}

type MyHidden interface {
	// AfterHidden Set post-hidden data hook.
	AfterHidden(fc func(ctx context.Context) (context.Context, error))

	// AfterHiddenValue Get post-hidden data hook.
	AfterHiddenValue() func(ctx context.Context) (context.Context, error)

	// BeforeHidden Set pre-hidden data hook.
	BeforeHidden(fc func(ctx context.Context) (context.Context, error))

	// BeforeHiddenValue Get pre-hidden data hook.
	BeforeHiddenValue() func(ctx context.Context) (context.Context, error)

	// HiddenFilter Custom hidden logic Filter.
	HiddenFilter(fc func(f Filter))

	// HiddenFilterValue Custom hidden logic Filter value.
	HiddenFilterValue() func(f Filter)

	// HiddenUpdate Set pseudo-delete logic method.
	HiddenUpdate(fc func(u SQLUpdateSet))

	// ResetHidden Reset the default Hidden method.
	ResetHidden(fc func(ctx context.Context, where Filter) (affectedRows int64, err error))

	// Hidden Logical deletion of data.
	Hidden(ctx context.Context, where Filter) (affectedRows int64, err error)

	// HiddenById Logical deletion of data.
	HiddenById(ctx context.Context, ids any) (affectedRows int64, err error)
}

type MyInsert interface {
	// AfterInsert Set post-insert data hook.
	AfterInsert(fc func(ctx context.Context) (context.Context, error))

	// AfterInsertValue Get post-insert data hook.
	AfterInsertValue() func(ctx context.Context) (context.Context, error)

	// BeforeInsert Set pre-insert data hook.
	BeforeInsert(fc func(ctx context.Context) (context.Context, error))

	// BeforeInsertValue Get pre-insert data hook.
	BeforeInsertValue() func(ctx context.Context) (context.Context, error)

	// ResetInsertOne Reset the default InsertOne method.
	ResetInsertOne(fc func(ctx context.Context, insert any) (id int64, err error))

	// ResetInsertAll Reset the default InsertAll method.
	ResetInsertAll(fc func(ctx context.Context, insert any) (affectedRows int64, err error))

	// ResetInsertFromQuery Reset the default InsertFromQuery method.
	ResetInsertFromQuery(fc func(ctx context.Context, columns []string, query Maker) (affectedRows int64, err error))

	// InsertOne Insert a record and return the primary key value (usually an integer value).
	InsertOne(ctx context.Context, insert any) (id int64, err error)

	// InsertAll Insert multiple records and return the number of rows affected.
	InsertAll(ctx context.Context, insert any) (affectedRows int64, err error)

	// InsertFromQuery Insert the query result data into the table, for example: data statistics table.
	InsertFromQuery(ctx context.Context, columns []string, query Maker) (affectedRows int64, err error)
}

type MySchema interface {
	MyInsert
	MyDelete
	MyUpdate
	MySelect
	MyHidden
}

type MySelect interface {
	// Table Get table name.
	Table() string

	// Columns Get table columns.
	Columns() []string

	// SelectFilter Custom select logic Filter.
	SelectFilter(fc func(f Filter))

	// SelectFilterValue Custom select logic Filter value.
	SelectFilterValue() func(f Filter)

	// ResetSelect Reset the default Select method.
	ResetSelect(fc func(ctx context.Context, selectAll func(ctx context.Context, table *Table) error, options ...func(o *Table)) error)

	// SelectAll Query multiple data.
	SelectAll(ctx context.Context, receiver any, options ...func(o *Table)) error

	// SelectOne Query a piece of data.
	SelectOne(ctx context.Context, receiver any, options ...func(o *Table)) error

	// SelectAllById Query multiple data.
	SelectAllById(ctx context.Context, ids any, receiver any, options ...func(o *Table)) error

	// SelectOneById Query a piece of data.
	SelectOneById(ctx context.Context, id any, receiver any, options ...func(o *Table)) error

	// SelectSQL Construct a subquery as a query table or CTE.
	SelectSQL(options ...func(o *Table)) *SQL

	// SelectExists Check whether the data exists.
	SelectExists(ctx context.Context, options ...func(o *Table)) (bool, error)

	// SelectCount Total number of statistical records.
	SelectCount(ctx context.Context, options ...func(o *Table)) (count int64, err error)

	// SelectCountFetch First count the total number of entries, then scan the list data.
	SelectCountFetch(ctx context.Context, receiver any, options ...func(o *Table)) (count int64, err error)

	// F Quickly create a new Filter instance.
	F() Filter

	// Equal Filter.Equal
	Equal(column any, value any) Filter

	// In Filter.In
	In(column any, values ...any) Filter

	// InGroup Filter.InGroup
	InGroup(columns any, values any) Filter

	// IdEqual Filter.Equal using id.
	IdEqual(value any) Filter

	// IdIn Filter.In using id.
	IdIn(values ...any) Filter

	// LikeSearch Keyword search matches multiple columns.
	LikeSearch(keyword string, columns ...string) Filter
}

type MyUpdate interface {
	// AfterUpdate Set post-update data hook.
	AfterUpdate(fc func(ctx context.Context) (context.Context, error))

	// AfterUpdateValue Get post-update data hook.
	AfterUpdateValue() func(ctx context.Context) (context.Context, error)

	// BeforeUpdate Set pre-update data hook.
	BeforeUpdate(fc func(ctx context.Context) (context.Context, error))

	// BeforeUpdateValue Get pre-update data hook.
	BeforeUpdateValue() func(ctx context.Context) (context.Context, error)

	// UpdateFilter Custom update logic Filter.
	UpdateFilter(fc func(f Filter))

	// UpdateFilterValue Custom update logic Filter value.
	UpdateFilterValue() func(f Filter)

	// ResetUpdate Reset the default Update method.
	ResetUpdate(fc func(ctx context.Context, where Filter, update func(u SQLUpdateSet)) (affectedRows int64, err error))

	// Update Implementing updated data.
	Update(ctx context.Context, where Filter, update func(u SQLUpdateSet)) (affectedRows int64, err error)

	// UpdateById Implementing updated data.
	UpdateById(ctx context.Context, ids any, update func(u SQLUpdateSet)) (affectedRows int64, err error)

	// Modify Implementing updated data.
	Modify(ctx context.Context, where Filter, modify any) (affectedRows int64, err error)

	// ModifyById Implementing updated data.
	ModifyById(ctx context.Context, id any, modify any) (affectedRows int64, err error)
}

type Quantifier interface {
	GetQuantifier() string

	SetQuantifier(quantifierString string) Quantifier

	Equal(column any, subquery Maker) Quantifier

	NotEqual(column any, subquery Maker) Quantifier

	LessThan(column any, subquery Maker) Quantifier

	LessThanEqual(column any, subquery Maker) Quantifier

	MoreThan(column any, subquery Maker) Quantifier

	MoreThanEqual(column any, subquery Maker) Quantifier
}

type Replacer interface {
	Get(key string) string

	Set(key string, value string) Replacer

	Del(key string) Replacer

	Map() map[string]string

	GetAll(keys []string) []string
}

type RowsScanMakeSliceLength string

type SQL struct {
	// Prepare SQL fragments or SQL statements, which may contain SQL placeholders.
	Prepare string

	// Args The corresponding parameter list of the placeholder list.
	Args []any
}

type SQLAlias interface {
	Maker

	// GetSQL Get SQL statement.
	GetSQL() *SQL

	// SetSQL Set SQL statement.
	SetSQL(script any) SQLAlias

	// GetAlias Get alias name value.
	GetAlias() string

	// SetAlias Set alias name value.
	SetAlias(alias string) SQLAlias

	// IsEmpty Verify whether the SQL statement is empty.
	IsEmpty() bool

	// ToEmpty Set both the SQL statement and the alias to empty values.
	ToEmpty() SQLAlias
}

type SQLCase interface {
	Maker

	// Alias Set alias name.
	Alias(alias string) SQLCase

	// Case SQL CASE.
	Case(value any) SQLCase

	// WhenThen Add WHEN xxx THEN xxx.
	WhenThen(when, then any) SQLCase

	// Else SQL CASE xxx ELSE xxx.
	Else(value any) SQLCase
}

type SQLComment interface {
	Maker

	ToEmpty

	// Comment Add comment.
	Comment(comment string) SQLComment
}

type SQLGroupBy interface {
	Maker

	ToEmpty

	// Group Set the grouping column, allowing string, []string, *SQL, []*SQL, Maker, []Maker.
	Group(group ...any) SQLGroupBy

	// Having Set the conditions filter HAVING statement after GROUP BY.
	Having(having func(having Filter)) SQLGroupBy
}

type SQLInsert interface {
	Maker

	ToEmpty

	// Table Insert data into the target table.
	Table(table Maker) SQLInsert

	// Forbid When inserting data, it is forbidden to set certain columns, such as: auto-increment id.
	Forbid(columns ...string) SQLInsert

	// GetForbid Get a list of columns that have been prohibited from insertion.
	GetForbid() []string

	// Select Set the columns to allow inserts only, not including defaults.
	Select(columns ...string) SQLInsert

	// Column Set the inserted column list. An empty value will delete the set field list.
	Column(columns ...string) SQLInsert

	// Values Set the list of values to be inserted.
	Values(values ...[]any) SQLInsert

	// Subquery Use the query result as the values of the insert statement.
	Subquery(subquery Maker) SQLInsert

	// ColumnValue Set a single column and value.
	ColumnValue(column string, value any) SQLInsert

	// Create Parses the given insert data and sets the insert data.
	Create(create any) SQLInsert

	// Default Set the default column for inserted data, such as the creation timestamp.
	Default(column string, value any) SQLInsert

	// Remove Delete a column-value.
	Remove(columns ...string) SQLInsert

	// Returning Insert a piece of data and get the auto-increment value.
	Returning(fc func(r SQLReturning)) SQLInsert

	// GetColumn Get the list of inserted columns that have been set.
	GetColumn(excludes ...string) []string

	// OnConflict When inserting data, set the execution logic when there is a conflict.
	OnConflict(fc func(o SQLOnConflict)) SQLInsert
}

type SQLJoin interface {
	Maker

	ToEmpty

	// GetTable Get join query the main table.
	GetTable() SQLAlias

	// SetTable Set join query the main table.
	SetTable(table SQLAlias) SQLJoin

	// Table Create a table for join query.
	Table(table any, alias string) SQLAlias

	// On Set the join query conditions.
	On(on func(on SQLJoinOn, table1alias string, table2alias string)) SQLJoinAssoc

	// Using The conditions for the join query use USING.
	Using(columns ...string) SQLJoinAssoc

	// OnEqual The join query conditions uses table1.column = table2.column.
	OnEqual(table1column string, table2column string) SQLJoinAssoc

	// Join Use the join type to set the table join relationship, if the table1 value is nil, use the main table.
	Join(joinType string, table1 SQLAlias, table2 SQLAlias, on SQLJoinAssoc) SQLJoin

	// InnerJoin Set the table join relationship, if the table1 value is nil, use the main table.
	InnerJoin(table1 SQLAlias, table2 SQLAlias, on SQLJoinAssoc) SQLJoin

	// LeftJoin Set the table join relationship, if the table1 value is nil, use the main table.
	LeftJoin(table1 SQLAlias, table2 SQLAlias, on SQLJoinAssoc) SQLJoin

	// RightJoin Set the table join relationship, if the table1 value is nil, use the main table.
	RightJoin(table1 SQLAlias, table2 SQLAlias, on SQLJoinAssoc) SQLJoin

	// Select Set the query column list.
	Select(columns ...any) SQLJoin

	// Prefix Set column prefix with the table name or table alias.
	Prefix(prefix SQLAlias, column string, aliases ...string) string

	// PrefixSelect Add a column list to the query based on the table alias or table name prefix.
	PrefixSelect(prefix SQLAlias, columns ...string) SQLJoin
}

type SQLJoinAssoc func(table1alias string, table2alias string) SQLJoinOn

type SQLJoinOn interface {
	Maker

	// Equal Use equal value JOIN ON condition.
	Equal(table1alias string, table1column string, table2alias string, table2column string) SQLJoinOn

	// On Append custom conditions to the ON statement or use custom conditions on the ON statement to associate tables.
	On(on func(f Filter)) SQLJoinOn

	// Using Use USING instead of ON.
	Using(columns ...string) SQLJoinOn
}

type SQLLimit interface {
	Maker

	ToEmpty

	// Limit SQL LIMIT.
	Limit(limit int64) SQLLimit

	// Offset SQL OFFSET.
	Offset(offset int64) SQLLimit

	// Page SQL LIMIT and OFFSET.
	Page(page int64, limit ...int64) SQLLimit
}

type SQLOnConflict interface {
	Maker

	ToEmpty

	// OnConflict The column causing the conflict, such as a unique key or primary key, which can be a single column or multiple columns.
	OnConflict(onConflicts ...string) SQLOnConflict

	// Do The SQL statement that needs to be executed when a data conflict occurs. By default, nothing is done.
	Do(maker Maker) SQLOnConflict

	// DoUpdateSet SQL update statements executed when data conflicts occur.
	DoUpdateSet(fc func(u SQLOnConflictUpdateSet)) SQLOnConflict
}

type SQLOnConflictUpdateSet interface {
	SQLUpdateSet

	// Excluded Construct the update expression column1 = EXCLUDED.column1, column2 = EXCLUDED.column2, column3 = EXCLUDED.column3 ...
	// This is how the `new` data is accessed that causes the conflict.
	Excluded(columns ...string) SQLOnConflictUpdateSet
}

type SQLOrderBy interface {
	Maker

	ToEmpty

	// Asc Build column1 ASC, column2 ASC, column3 ASC...
	Asc(columns ...string) SQLOrderBy

	// Desc Build column1 DESC, column2 DESC, column3 DESC...
	Desc(columns ...string) SQLOrderBy
}

type SQLReturning interface {
	Maker

	ToEmpty

	// Prepare When constructing a SQL statement that insert a row of data and return the id,
	// you may need to adjust the SQL statement, such as adding `RETURNING id` to the end of the insert statement.
	Prepare(prepare func(tmp *SQL)) SQLReturning

	// Returning Set the RETURNING statement to return one or more columns.
	Returning(columns ...string) SQLReturning

	// Execute When constructing a SQL statement that inserts a row of data and returns the id,
	// get the id value of the inserted row (this may vary depending on the database driver)
	Execute(execute func(ctx context.Context, stmt *Stmt, args ...any) (id int64, err error)) SQLReturning
}

type SQLSelect interface {
	Maker

	ToEmpty

	IsEmpty() bool

	// Distinct DISTINCT column1, column2, column3 ...
	Distinct() SQLSelect

	// Add Put Maker to the query list.
	Add(maker Maker) SQLSelect

	// Del Delete some columns from the query list. If not specified, delete all.
	Del(columns ...string) SQLSelect

	// Has Does the column exist in the query list?
	Has(column string) bool

	// Len Query list length.
	Len() int

	// Get Query list and its corresponding column parameter list.
	Get() (columns []string, args map[int][]any)

	// Set Query list and its corresponding column parameter list.
	Set(columns []string, args map[int][]any) SQLSelect

	// Select Add one or more query lists. If no parameter is provided, all existing query lists will be deleted.
	Select(columns ...any) SQLSelect
}

type SQLUpdateSet interface {
	Maker

	ToEmpty

	Len() int

	// Forbid Set a list of columns that cannot be updated.
	Forbid(columns ...string) SQLUpdateSet

	// GetForbid Get a list of columns that are prohibited from updating.
	GetForbid() []string

	// Select Set columns that only allow updates, not including defaults.
	Select(columns ...string) SQLUpdateSet

	// Set Update column assignment.
	Set(column string, value any) SQLUpdateSet

	// Decr Update column decrement.
	Decr(column string, decr any) SQLUpdateSet

	// Incr Update column increment.
	Incr(column string, incr any) SQLUpdateSet

	// SetMap Update column assignment by map.
	SetMap(columnValue map[string]any) SQLUpdateSet

	// SetSlice Update column assignment by slice.
	SetSlice(columns []string, values []any) SQLUpdateSet

	// Update Parse the given update data and assign the update value.
	Update(update any) SQLUpdateSet

	// Compare Compare struct assignment update.
	Compare(old, new any, except ...string) SQLUpdateSet

	// Default Set the default columns that need to be updated, such as update timestamp.
	Default(column string, value any) SQLUpdateSet

	// Remove Delete a column-value.
	Remove(columns ...string) SQLUpdateSet

	// Assign Assigning values through other column, null, empty string, subquery ...
	Assign(dst string, src string) SQLUpdateSet

	// GetUpdate Get a list of existing updates.
	GetUpdate() ([]string, [][]any)

	// SetUpdate Delete the existing update list and set the update list.
	SetUpdate(updates []string, params [][]any) SQLUpdateSet
}

type SQLValues interface {
	Maker

	ToEmpty

	IsEmpty() bool

	// Subquery The inserted data is a subquery.
	Subquery(subquery Maker) SQLValues

	// Values The inserted data of VALUES.
	Values(values ...[]any) SQLValues
}

type SQLWindowFuncFrame interface {
	Maker

	// SQL Custom SQL statement.
	SQL(value any) SQLWindowFuncFrame

	// UnboundedPreceding Start of partition.
	UnboundedPreceding() *SQL

	// NPreceding First n rows.
	NPreceding(n int) *SQL

	// CurrentRow Current row.
	CurrentRow() *SQL

	// NFollowing After n rows.
	NFollowing(n int) *SQL

	// UnboundedFollowing End of partition.
	UnboundedFollowing() *SQL

	// Between Build BETWEEN start AND end.
	Between(fc func(ff SQLWindowFuncFrame) (*SQL, *SQL)) SQLWindowFuncFrame
}

type SQLWith interface {
	Maker

	ToEmpty

	// Recursive Recursion or cancellation of recursion.
	Recursive() SQLWith

	// Set Setting common table expression.
	Set(alias string, maker Maker, columns ...string) SQLWith

	// Del Removing common table expression.
	Del(alias string) SQLWith
}

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

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

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

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

type TableNamer interface {
	// Table Get the table name.
	Table() string
}

type ToEmpty interface {
	// ToEmpty Sets the property value of an object to empty value.
	ToEmpty()
}

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

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