hey

package module
v6.1.2 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jan 23, 2026 License: MIT Imports: 20 Imported by: 0

README

What is hey?

Hey is a Go-based SQL builder and ORM.
It has no third-party library dependencies and does not restrict you to using any drivers.
It supports common databases such as PostgreSQL, MySQL, SQLite...
When constructing regular SQL, you only need to set the identifier and its corresponding value.
During the development phase, you can view the dynamically generated SQL statements at any time.
Log the executed SQL statements and transactions(Use it as an ORM).

hey's mission

  1. Support as many SQL general syntax as possible.
  2. Write less or no original strings in business code, such as "username", "SUM(salary)", "id = ?", "SELECT id, name FROM your_table_name" ...
  3. Try to avoid using reflection when scanning and querying data to reduce time consumption.
  4. Through the template code of the table structure, when the database table structure changes, your code can immediately perceive it.
  5. When you implement a business, focus more on the business rather than on building SQL statements.
  6. Allows the use of custom caches to reduce query request pressure on relational databases.
  7. It (hey) can help you build complex SQL statements, especially complex query SQL statements.
  8. Allows you to define a set of commonly used template SQL statements and use them in complex SQL statements.
  9. Allows you to efficiently build the SQL statements you need.

INSTALL

go get github.com/cd365/hey/v6@latest

EXAMPLE

Currently, only PostgreSQL is used in this case; the usage methods for other databases are similar.
All
PostgreSQL

Documentation

Index

Constants

View Source 
const (
	// ErrNoDataInCache No data in cache.
	ErrNoDataInCache = Err("hey: no data in cache")

	// ErrEmptyCacheKey Empty cache key.
	ErrEmptyCacheKey = Err("hey: empty cache key")
)
View Source 
const (
	// ErrEmptySqlStatement Error empty sql statement.
	ErrEmptySqlStatement = Err("hey: empty sql statement")

	// ErrNoRowsAffected Error no rows affected.
	ErrNoRowsAffected = Err("hey: no rows affected")

	// ErrNoWhereCondition Error no where condition.
	ErrNoWhereCondition = Err("hey: no where condition")

	// ErrTransactionIsNil Error transaction is nil.
	ErrTransactionIsNil = Err("hey: transaction is nil")

	// ErrDatabaseIsNil Error database is nil.
	ErrDatabaseIsNil = Err("hey: database is nil")

	// ErrMethodNotImplemented Error method not implemented.
	ErrMethodNotImplemented = Err("hey: method not implemented")

	// ErrInvalidMaker Error invalid maker.
	ErrInvalidMaker = Err("hey: invalid maker")
)
View Source 
const (
	DefaultTag      = "db"
	TableMethodName = "TableName"
)

Variables

This section is empty.

Functions

func AnyAny 

func AnyAny[T any](slice []T) []any

AnyAny Convert any type of slice to []any.

func ArrayDiscard 

func ArrayDiscard[V any](values []V, discard func(k int, v V) bool) []V

ArrayDiscard Delete some elements from a slice.

func ArrayToArray 

func ArrayToArray[V any, W any](values []V, fc func(k int, v V) W) []W

ArrayToArray Create a slice from another slice.

func ArrayToMap 

func ArrayToMap[V any, K comparable, W any](values []V, fc func(v V) (K, W)) map[K]W

ArrayToMap Create a map from a slice.

func DiscardDuplicate 

func DiscardDuplicate[T comparable](discard func(tmp T) bool, dynamic ...T) (result []T)

DiscardDuplicate Slice deduplication.

func DropTable 

func DropTable(ctx context.Context, db *sql.DB, tables ...string) error

DropTable DROP TABLE. Data is priceless! You should back up your data before calling this function unless you are very sure what you are doing.

func ExecuteScript 

func ExecuteScript(ctx context.Context, db *sql.DB, execute string, args ...any) error

ExecuteScript Execute SQL script.

func InGroupValues 

func InGroupValues[T any](values []T, fc func(tmp T) []any) [][]any

InGroupValues Build ( column1, column2, column3 ... ) IN ( ( values[0].attribute1, values[0].attribute2, values[0].attribute3 ... ), ( values[1].attribute1, values[1].attribute2, values[1].attribute3 ... ) ... )

func InValues 

func InValues[T any](values []T, fc func(tmp T) any) []any

InValues Build column IN ( values[0].attributeN, values[1].attributeN, values[2].attributeN ... )

func JoinString 

func JoinString(elems ...string) string

JoinString Concatenate multiple strings in sequence.

func KeepOnlyFirst 

func KeepOnlyFirst[T any](i []T) []T

KeepOnlyFirst Only use the first element value.

func KeepOnlyLast 

func KeepOnlyLast[T any](i []T) []T

KeepOnlyLast Only use the value of the last element.

func LastNotEmptyString 

func LastNotEmptyString(sss []string) string

LastNotEmptyString Get last not empty string, return empty string if it does not exist.

func MakerScanAll 

func MakerScanAll[V any](ctx context.Context, way *Way, maker Maker, scan func(rows *sql.Rows, v *V) error) ([]*V, error)

MakerScanAll Rows scan to any struct, based on struct scan data.

func MakerScanOne 

func MakerScanOne[V any](ctx context.Context, way *Way, maker Maker, scan func(rows *sql.Rows, v *V) error) (*V, error)

MakerScanOne Rows scan to any struct, based on struct scan data. Scan a piece of data, don't forget to use LIMIT 1 in your SQL statement.

func MapDiscard 

func MapDiscard[K comparable, V any](values map[K]V, discard func(k K, v V) bool) map[K]V

MapDiscard Delete some elements from the map.

func MapToArray 

func MapToArray[K comparable, V any, W any](values map[K]V, fc func(k K, v V) W) []W

MapToArray Create a slice from a map.

func MapToMap 

func MapToMap[K comparable, V any, X comparable, Y any](values map[K]V, fc func(k K, v V) (X, Y)) map[X]Y

MapToMap Create a map based on another map.

func MergeArray 

func MergeArray[V any](values ...[]V) []V

MergeArray Merge slices.

func MergeMap 

func MergeMap[K comparable, V any](values ...map[K]V) map[K]V

MergeMap Merge maps.

func ObjectInsert 

func ObjectInsert(object any, tag string, except []string, allow []string) (columns []string, values [][]any)

ObjectInsert Object should be one of map[string]any, []map[string]any, struct{}, *struct{}, []struct, []*struct{}, *[]struct{}, *[]*struct{}.

func ObjectModify 

func ObjectModify(object any, tag string, except ...string) (columns []string, values []any)

ObjectModify Object should be one of map[string]any, anyStruct, *anyStruct get the columns and values that need to be modified.

func ObjectObtain 

func ObjectObtain(object any, tag string, except ...string) (columns []string, values []any)

ObjectObtain Object should be one of map[string]any, anyStruct, *anyStruct for get all columns and values.

func ParcelCancelPrepare 

func ParcelCancelPrepare(prepare string) string

ParcelCancelPrepare Cancel parcel the SQL statement. ( `subquery` ) => `subquery` OR ( ( `subquery` ) ) => ( `subquery` )

func ParcelPrepare 

func ParcelPrepare(prepare string) string

ParcelPrepare Parcel the SQL statement. `subquery` => ( `subquery` )

func Prefix 

func Prefix(prefix string, name string) string

Prefix Add SQL prefix name; if the prefix exists, it will not be added.

func QuickScan 

func QuickScan(
	rows *sql.Rows,
	adjustColumnValue func(columnTypes []*sql.ColumnType, results []map[string]any) error,
) ([]map[string]any, error)

QuickScan Quickly scan query results into []map[string]any.

func RowsScan 

func RowsScan(rows *sql.Rows, result any, tag string) error

RowsScan Scan the query result set into the receiving object. Support type *AnyStruct, **AnyStruct, *[]AnyStruct, *[]*AnyStruct, **[]AnyStruct, **[]*AnyStruct, *[]int, *[]float64, *[]string ...

func SQLString 

func SQLString(value string) string

SQLString Convert a go string to a SQL string.

func SQLToString 

func SQLToString(script *SQL) string

SQLToString Use parameter values to replace placeholders in SQL statements and build a visual SQL script. Warning: Binary byte slice will be converted to hexadecimal strings.

func StructUpdate 

func StructUpdate(origin any, latest any, tag string, except ...string) (columns []string, values []any)

StructUpdate Compare origin and latest for update.

func TruncateTable 

func TruncateTable(ctx context.Context, db *sql.DB, tables ...string) error

TruncateTable TRUNCATE TABLE. Data is priceless! You should back up your data before calling this function unless you are very sure what you are doing.

func ValueCamel 

func ValueCamel(value string) string

ValueCamel Camel case.

func ValuePascal 

func ValuePascal(value string) string

ValuePascal Pascal case.

func ValueUnderline 

func ValueUnderline(value string) string

ValueUnderline Underline case.

func WayContext 

func WayContext(ctx context.Context, way *Way) context.Context

WayContext Store *Way in the context.

Types

type AdjustColumnAnyValue 

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

type Cache 

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

Cache Read and write data in cache.

func NewCache 

func NewCache(cacher Cacher) *Cache

NewCache Create a new *Cache object.

func (*Cache) Del 

func (s *Cache) Del(ctx context.Context, key string) error

Del Deleting data from the cache.

func (*Cache) Get 

func (s *Cache) Get(ctx context.Context, key string) ([]byte, error)

Get Read cache data from cache.

func (*Cache) GetBool 

func (s *Cache) GetBool(ctx context.Context, key string) (bool, error)

GetBool Read bool cache data from cache.

func (*Cache) GetCacher 

func (s *Cache) GetCacher() Cacher

GetCacher Read Cacher.

func (*Cache) GetFloat 

func (s *Cache) GetFloat(ctx context.Context, key string) (float64, error)

GetFloat Read float64 cache data from cache.

func (*Cache) GetInt 

func (s *Cache) GetInt(ctx context.Context, key string) (int64, error)

GetInt Read int64 cache data from cache.

func (*Cache) GetString 

func (s *Cache) GetString(ctx context.Context, key string) (string, error)

GetString Read string cache data from cache.

func (*Cache) GetUnmarshal 

func (s *Cache) GetUnmarshal(ctx context.Context, key string, value any) error

GetUnmarshal Read cached data from the cache and deserialize cached data.

func (*Cache) Has 

func (s *Cache) Has(ctx context.Context, key string) (bool, error)

Has Is there data in the cache?

func (*Cache) Maker 

func (s *Cache) Maker(maker Maker) CacheMaker

Maker New CacheMaker.

func (*Cache) MarshalSet 

func (s *Cache) MarshalSet(ctx context.Context, key string, value any, duration time.Duration) error

MarshalSet Serialize cache data and write the serialized data to the cache.

func (*Cache) RangeRandomDuration 

func (s *Cache) RangeRandomDuration(baseDuration time.Duration, minValue int, maxValue int) time.Duration

RangeRandomDuration Get a random Duration between minValue*baseDuration and maxValue*baseDuration.

func (*Cache) Set 

func (s *Cache) Set(ctx context.Context, key string, value []byte, duration time.Duration) error

Set Write cache data to cache.

func (*Cache) SetBool 

func (s *Cache) SetBool(ctx context.Context, key string, value bool, duration time.Duration) error

SetBool Write bool cache data to cache.

func (*Cache) SetCacher 

func (s *Cache) SetCacher(cacher Cacher) *Cache

SetCacher Write Cacher.

func (*Cache) SetFloat 

func (s *Cache) SetFloat(ctx context.Context, key string, value float64, duration time.Duration) error

SetFloat Write float64 cache data to cache.

func (*Cache) SetInt 

func (s *Cache) SetInt(ctx context.Context, key string, value int64, duration time.Duration) error

SetInt Write int64 cache data to cache.

func (*Cache) SetString 

func (s *Cache) SetString(ctx context.Context, key string, value string, duration time.Duration) error

SetString Write string cache data to cache.

type CacheMaker 

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

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

	// Get For get value from cache.
	Get(ctx context.Context) ([]byte, error)

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

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

	// Has Is there data in the cache?
	Has(ctx context.Context) (bool, error)

	// GetUnmarshal Query data and unmarshal data.
	GetUnmarshal(ctx context.Context, value any) error

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

	// GetString Get string type value.
	GetString(ctx context.Context) (string, error)

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

	// GetFloat Get float64 type value.
	GetFloat(ctx context.Context) (float64, error)

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

	// GetInt Get int64 type value.
	GetInt(ctx context.Context) (int64, error)

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

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

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

CacheMaker Cache SQL statement related data, including but not limited to cache query data.

func NewCacheMaker 

func NewCacheMaker(cache *Cache, maker Maker) CacheMaker

NewCacheMaker Create a new CacheMaker object.

type CacheQuery 

type CacheQuery interface {
	// Cache Get Cache.
	Cache() *Cache

	// MultiMutex Get MultiMutex.
	MultiMutex() MultiMutex

	// CacheKey Using custom method to build cache key.
	CacheKey(cacheKey func(maker Maker) (string, error)) CacheQuery

	// RangeRandomDuration Get a random Duration between minValue*baseDuration and maxValue*baseDuration.
	RangeRandomDuration(baseDuration time.Duration, minValue int, maxValue int) time.Duration

	// Del Delete data from cache by maker.
	Del(ctx context.Context, maker Maker) error

	// Has Is there data in the cache?
	Has(ctx context.Context, maker Maker) (bool, error)

	// Get First, query the cache for data; if the data is not found in the cache, then query the database.
	// It is strongly recommended to use slicing to cache data to avoid getting an ErrNoRows error when querying a single data record.
	Get(ctx context.Context, maker Maker, data any, duration time.Duration) error
}

CacheQuery Use cache to query data.

func NewCacheQuery 

func NewCacheQuery(cache *Cache, multiMutex MultiMutex, way *Way) CacheQuery

type Cacher 

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

	// Get Reading data from the cache, if the data does not exist, an ErrNoDataInCache error should be returned.
	Get(ctx context.Context, key string) ([]byte, error)

	// Set Writing data to the cache, a cache duration of 0 or a negative number indicates a permanent cache.
	Set(ctx context.Context, key string, value []byte, duration time.Duration) error

	// Del Deleting data from the cache.
	Del(ctx context.Context, key string) error

	// Has Is there data in the cache?
	Has(ctx context.Context, key string) (bool, error)

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

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

Cacher Cache interface.

type Complex 

type Complex interface {
	// Upsert Update or insert data.
	Upsert(ctx context.Context) (updateAffectedRows int64, insertResult int64, err error)

	// DeleteCreate Delete data first, then insert data.
	DeleteCreate(ctx context.Context) (deleteAffectedRows int64, insertResult int64, err error)
}

Complex Execute a set of SQL statements within a transaction.

func NewComplex 

func NewComplex(table *Table) Complex

NewComplex Create a Complex object.

type Err 

type Err string

func (Err) Error 

func (s Err) Error() string

type ExtractFilter 

type ExtractFilter interface {
	// Delimiter Custom a delimiter string is used to split the target string.
	Delimiter(delimiter string) ExtractFilter

	// BetweenInt Use a delimiter string to separate multiple element values, with ',' as the default.
	// column BETWEEN int-min AND int-max, column >= int-min, column <= int-max
	BetweenInt(column string, value *string, verifies ...func(minimum int, maximum int) bool) ExtractFilter

	// BetweenInt64 Use a delimiter string to separate multiple element values, with ',' as the default.
	// column BETWEEN int64-min AND int64-max, column >= int64-min, column <= int64-max
	BetweenInt64(column string, value *string, verifies ...func(minimum int64, maximum int64) bool) ExtractFilter

	// BetweenFloat64 Use a delimiter string to separate multiple element values, with ',' as the default.
	// column BETWEEN float64-min AND float64-max, column >= float64-min, column <= float64-max
	BetweenFloat64(column string, value *string, verifies ...func(minimum float64, maximum float64) bool) ExtractFilter

	// BetweenString Use a delimiter string to separate multiple element values, with ',' as the default.
	// column BETWEEN string-min AND string-max, column >= string-min, column <= string-max
	BetweenString(column string, value *string, verifies ...func(minimum string, maximum string) bool) ExtractFilter

	// InInt Use a delimiter string to separate multiple element values, with ',' as the default.
	// column IN ( int-value1, int-value2, int-value3 ... )
	InInt(column string, value *string, verify func(index int, value int) bool, keepOnly func(i []int) []int) ExtractFilter

	// InInt64 Use a delimiter string to separate multiple element values, with ',' as the default.
	// column IN ( int64-value1, int64-value2, int64-value3 ... )
	InInt64(column string, value *string, verify func(index int, value int64) bool, keepOnly func(i []int64) []int64) ExtractFilter

	// InString Use a delimiter string to separate multiple element values, with ',' as the default.
	// column IN ( string-value1, string-value2, string-value3 ... )
	InString(column string, value *string, verify func(index int, value string) bool, keepOnly func(i []string) []string) ExtractFilter

	// InIntDirect A simplified method for convenient use.
	InIntDirect(column string, value *string) ExtractFilter

	// InInt64Direct A simplified method for convenient use.
	InInt64Direct(column string, value *string) ExtractFilter

	// InStringDirect A simplified method for convenient use.
	InStringDirect(column string, value *string) ExtractFilter

	// InIntVerify A simplified method for convenient use.
	InIntVerify(column string, value *string, verify func(index int, value int) bool) ExtractFilter

	// InInt64Verify A simplified method for convenient use.
	InInt64Verify(column string, value *string, verify func(index int, value int64) bool) ExtractFilter

	// InStringVerify A simplified method for convenient use.
	InStringVerify(column string, value *string, verify func(index int, value string) bool) ExtractFilter

	// LikeSearch Fuzzy search for a single keyword across multiple column values, ( column1 LIKE '%value%' OR column2 LIKE '%value%' OR column3 LIKE '%value%' ... )
	LikeSearch(value *string, columns ...string) ExtractFilter
}

ExtractFilter Extract the available condition values for the Filter. Use a delimiter string to separate multiple element values, with ',' as the default.

type Filter 

type Filter interface {
	Maker

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

	// Clone Copy the current object.
	Clone() 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(maker Maker) Filter

	// Or Use logical operator `OR` to combine custom conditions.
	Or(maker Maker) 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) 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

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

	// GreaterThanEqual Implement conditional filtering: column >= value .
	GreaterThanEqual(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) 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

	// Keyword Implement the filter condition: ( column1 LIKE 'value' OR column2 LIKE 'value' OR column3 LIKE 'value' ... ) .
	Keyword(keyword string, columns ...string) 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 Replacer.
	GetReplacer() Replacer

	// SetReplacer For set Replacer.
	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

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

	// CompareGreaterThanEqual Implement conditional filtering: script1 >= script2 .
	CompareGreaterThanEqual(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

	// ExtractFilter Call Filter using ExtractFilter.
	ExtractFilter(fc func(f ExtractFilter)) Filter

	// TimeFilter Call Filter using TimeFilter.
	TimeFilter(fc func(f TimeFilter)) Filter
}

Filter Implement SQL statement conditional filtering (general conditional filtering).

func F 

func F() Filter

F New a Filter.

type Limiter 

type Limiter interface {
	GetLimit() int64

	GetOffset() int64
}

Limiter limit and offset.

type Maker 

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

Maker Build SQL fragments or SQL statements, which may include corresponding parameter lists. Notice: The ToSQL method must return a non-nil value for *SQL.

type Manual 

type Manual struct {
	// Replacer SQL Identifier Replacer.
	Replacer Replacer

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

	// InsertOneAndReturnId Insert a record and return the id value of the inserted data.
	InsertOneAndReturnId func(r SQLReturning)

	// DatabaseType Database type value.
	DatabaseType cst.DatabaseType
}

Manual For handling different types of databases.

func Mysql 

func Mysql() *Manual

func Postgresql 

func Postgresql() *Manual

func Sqlite 

func Sqlite() *Manual

func (*Manual) InsertOneAndScanInsertId added in v6.1.2 

func (s *Manual) InsertOneAndScanInsertId() func(r SQLReturning)

InsertOneAndScanInsertId INSERT INTO xxx RETURNING id

func (*Manual) InsertOneGetLastInsertId added in v6.1.2 

func (s *Manual) InsertOneGetLastInsertId() func(r SQLReturning)

InsertOneGetLastInsertId INSERT INTO xxx; sql.Result

type Map 

type Map interface {
	// Get Getting the value corresponding to a key from the map.
	Get(key string) (value any, has bool)

	// Set Storing key-value to the map.
	Set(key string, value any) Map

	// Has Checking if the key exists in the map.
	Has(key string) bool

	// Del Deleting map key.
	Del(key string) Map

	// Map Getting the map value.
	Map() map[string]any

	// Len Getting the map length.
	Len() int

	// IsEmpty Is the map empty?
	IsEmpty() bool

	// ToEmpty Setting the map to empty value.
	ToEmpty() Map
}

Map Store key-value to the map.

func NewMap 

func NewMap() Map

type MapScanner 

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)
}

MapScanner Scanning the query results into []map[string]any.

func NewMapScanner 

func NewMapScanner() MapScanner

NewMapScanner Exposes a default implementation of the MapScanner interface.

type MultiMutex 

type MultiMutex interface {
	// Get returns the sync.Mutex corresponding to the given key.
	Get(key string) *sync.Mutex

	// Len returns the number of mutexes.
	Len() int
}

MultiMutex Maps string keys to a fixed set of *sync.Mutex locks using hashing.

func NewMultiMutex 

func NewMultiMutex(length int) MultiMutex

NewMultiMutex creates a new MultiMutex with the specified number of mutexes. If length is invalid (< 1 or > math.MaxUint16), it defaults to 256.

type MyContext 

type MyContext string

MyContext Custom context key type. 

const (
	// MyWay Store the *hey.Way, *hey.Way.
	MyWay MyContext = "HEY_MY_WAY"

	// MyTable Store the *hey.Table, *hey.Table.
	MyTable MyContext = "HEY_MY_TABLE"

	// MyTableName Store the original table name, string.
	MyTableName MyContext = "HEY_MY_TABLE_NAME"

	// MyAffectedRows Store the number of rows affected, int64.
	MyAffectedRows MyContext = "HEY_MY_AFFECTED_ROWS"

	// MyInsertOne Store the status for inserting a piece of data, bool.
	MyInsertOne MyContext = "HEY_MY_INSERT_ONE"

	// MyInsertAll Store the status for inserting multiple records status, bool.
	MyInsertAll MyContext = "HEY_MY_INSERT_ALL"

	// MyInsertData Store the inserted data, any.
	MyInsertData MyContext = "HEY_MY_INSERT_DATA"

	// MyInsertId Store the inserted id value, int64.
	MyInsertId MyContext = "HEY_MY_INSERT_ID"

	// MyInsertQuery Insert the query result data into the table, for example: data statistics table, *SQL.
	MyInsertQuery MyContext = "HEY_MY_INSERT_QUERY"
)

type MyDelete 

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

	// AfterDeleteValue Get post-delete data hook.
	AfterDeleteValue() func(ctx 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)
}

MyDelete For DELETE.

type MyHidden 

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

	// AfterHiddenValue Get post-hidden data hook.
	AfterHiddenValue() func(ctx 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)
}

MyHidden Logical deletion of data.

type MyInsert 

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

	// AfterInsertValue Get post-insert data hook.
	AfterInsertValue() func(ctx 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)
}

MyInsert For INSERT.

type MyMulti 

type MyMulti interface {
	Run

	ToEmpty

	V

	W

	// Len Number of SQL statements to be executed.
	Len() int

	// IsEmpty Are there no pending SQL statements?
	IsEmpty() bool

	// Add custom logic.
	Add(values ...func(ctx context.Context) error) MyMulti

	// AddExists Add a query exists statement.
	AddExists(maker Maker, exists *bool) MyMulti

	// AddQuery Add a query statement; `result` is the container for processing or storing the returned results.
	AddQuery(maker Maker, result any) MyMulti

	// AddQueryRow Add a non-query statement; `dest` is the container for processing or storing the returned results.
	AddQueryRow(maker Maker, dest ...any) MyMulti

	// RowsAffected Get the number of affected rows.
	RowsAffected(rows *int64) func(value sql.Result) error

	// LastInsertId Get the id of the last inserted data.
	LastInsertId(id *int64) func(value sql.Result) error

	// AddExec Add a non-query statement; `result` is the container for processing or storing the returned results.
	// If the value of `result` is empty, the number of affected rows will be discarded.
	AddExec(maker Maker, result ...any) MyMulti
}

MyMulti This stacks multiple SQL statements sequentially and executes them one by one at the end. You can add custom logic anywhere. For each SQL statement to be executed, you only need to focus on the following three points: 1. The SQL statement to be executed and its corresponding parameter list. 2. Receive or process SQL execution results. 3. Should custom logic be executed after the SQL statement executes successfully?

type MySchema 

type MySchema interface {
	MyInsert
	MyDelete
	MyUpdate
	MySelect
	MyHidden
}

MySchema Combo MyInsert, MyDelete, MyUpdate, MySelect, MyHidden interfaces.

type MySelect 

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)

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

MySelect For SELECT.

type MyTrack 

type MyTrack struct {
	// Context Value of context.
	Context context.Context

	// Type Track type.
	Type MyTrackType

	// TimeStart Start time.
	TimeStart time.Time

	// TimeEnd End time.
	TimeEnd time.Time

	// Err Error value.
	Err error

	// TxId Transaction id.
	TxId string

	// TxMsg Transaction message.
	TxMsg string

	// TxState Transaction state.
	TxState string

	// Prepare Original SQL statement.
	Prepare string

	// Script SQL Script.
	Script string

	// Args The parameter list corresponding to the original SQL statement.
	Args []any
}

MyTrack Implement Track interface.

type MyTrackType 

type MyTrackType string
const (
	TrackDebug       MyTrackType = "DEBUG"
	TrackSQL         MyTrackType = "SQL"
	TrackTransaction MyTrackType = "TRANSACTION"
)

type MyUpdate 

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

	// AfterUpdateValue Get post-update data hook.
	AfterUpdateValue() func(ctx 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)
}

MyUpdate For UPDATE.

type Option 

type Option func(way *Way)

func WithDatabase 

func WithDatabase(db *sql.DB) Option

func WithDefaultPageSize 

func WithDefaultPageSize(pageSize int64) Option

func WithDeleteRequireWhere 

func WithDeleteRequireWhere(deleteRequireWhere bool) Option

func WithInsertForbidColumn added in v6.0.2 

func WithInsertForbidColumn(insertForbidColumn []string) Option

func WithLimit 

func WithLimit(limit func(way *Way) SQLLimit) Option

func WithManual 

func WithManual(manual *Manual) Option

func WithMapScanner 

func WithMapScanner(mapScanner MapScanner) Option

func WithMaxLimit 

func WithMaxLimit(maxLimit int64) Option

func WithMaxOffset 

func WithMaxOffset(maxOffset int64) Option

func WithReader 

func WithReader(reader Reader) Option

func WithScan 

func WithScan(scan func(rows *sql.Rows, result any, tag string) error) Option

func WithScanTag 

func WithScanTag(scanTag string) Option

func WithTableMethodName 

func WithTableMethodName(tableMethodName string) Option

func WithTrack 

func WithTrack(track Track) Option

func WithTxMaxDuration 

func WithTxMaxDuration(txMaxDuration time.Duration) Option

func WithTxOptions 

func WithTxOptions(txOptions *sql.TxOptions) Option

func WithUpdateForbidColumn added in v6.0.2 

func WithUpdateForbidColumn(updateForbidColumn []string) Option

func WithUpdateRequireWhere 

func WithUpdateRequireWhere(updateRequireWhere bool) Option

type Quantifier 

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

	GreaterThan(column any, subquery Maker) Quantifier

	GreaterThanEqual(column any, subquery Maker) Quantifier
}

Quantifier Implement the filter condition: column {=||<>||>||>=||<||<=} [QUANTIFIER ]( subquery ) . QUANTIFIER is usually one of ALL, ANY, SOME ... or EmptyString.

type RangeRandomDuration 

type RangeRandomDuration interface {
	// Get a random duration.
	Get() time.Duration

	// GetBaseDuration Get base duration.
	GetBaseDuration() time.Duration

	// SetBaseDuration Set base duration.
	SetBaseDuration(baseDuration time.Duration) RangeRandomDuration

	// GetRange Get duration range.
	GetRange() (int, int)

	// SetRange Set duration range.
	SetRange(minValue int, maxValue int) RangeRandomDuration
}

RangeRandomDuration Get a random duration within a range.

func NewRangeRandomDuration 

func NewRangeRandomDuration(baseDuration time.Duration, minValue int, maxValue int) RangeRandomDuration

NewRangeRandomDuration The minimum value of all values should be granter than 0, unless you want to cache permanently.

type Reader 

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

Reader Separate read and write, when you distinguish between reading and writing, please do not use the same object for both reading and writing.

func NewReader 

func NewReader(choose func(n int) int, reads []*Way) Reader

NewReader It is recommended that objects used for writing should not appear in reads.

type Replacer 

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
}

Replacer SQL Identifier Replacer. All identifier mapping relationships should be set before the program is initialized. They cannot be set again while the program is running to avoid concurrent reading and writing of the map.

func NewReplacer 

func NewReplacer() Replacer

type RowsScanMakeSliceLength 

type RowsScanMakeSliceLength string
const (
	MakerScanAllMakeSliceLength RowsScanMakeSliceLength = "maker_scan_all_make_slice_length"
)

type Run 

type Run interface {
	// Run Call all stored business logic.
	Run(ctx context.Context) error
}

Run Call all stored business logic.

type SQL 

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
}

SQL Prepare SQL statements and parameter lists corresponding to placeholders.

func AnyToSQL 

func AnyToSQL(i any) *SQL

AnyToSQL Convert values of any type into SQL expressions or SQL statements.

func Avg 

func Avg(values ...any) *SQL

func CloneSQL 

func CloneSQL(src *SQL) *SQL

CloneSQL Clone *SQL.

func Coalesce 

func Coalesce(values ...any) *SQL

func Count 

func Count(values ...any) *SQL

func ExceptAllSQL 

func ExceptAllSQL(scripts ...*SQL) *SQL

ExceptAllSQL *SQL1, *SQL2, *SQL3 ... => ( QUERY_A ) EXCEPT ALL ( QUERY_B ) EXCEPT ALL ( QUERY_C )...

func ExceptSQL 

func ExceptSQL(scripts ...*SQL) *SQL

ExceptSQL *SQL1, *SQL2, *SQL3 ... => ( QUERY_A ) EXCEPT ( QUERY_B ) EXCEPT ( QUERY_C )...

func FuncSQL 

func FuncSQL(funcName string, funcArgs ...any) *SQL

func IntersectAllSQL 

func IntersectAllSQL(scripts ...*SQL) *SQL

IntersectAllSQL *SQL1, *SQL2, *SQL3 ... => ( QUERY_A ) INTERSECT ALL ( QUERY_B ) INTERSECT ALL ( QUERY_C )...

func IntersectSQL 

func IntersectSQL(scripts ...*SQL) *SQL

IntersectSQL *SQL1, *SQL2, *SQL3 ... => ( QUERY_A ) INTERSECT ( QUERY_B ) INTERSECT ( QUERY_C )...

func JoinMaker 

func JoinMaker(elems []Maker, sep string) *SQL

JoinMaker Concatenate multiple SQL scripts and their parameter lists using a specified delimiter.

func JoinSQL 

func JoinSQL(elems []any, sep string) *SQL

JoinSQL Use `separator` to concatenate multiple SQL scripts and parameters.

func JoinSQLComma 

func JoinSQLComma(values ...any) *SQL

JoinSQLComma Use "," to concatenate multiple SQL scripts and parameters.

func JoinSQLCommaSpace 

func JoinSQLCommaSpace(values ...any) *SQL

JoinSQLCommaSpace Use ", " to concatenate multiple SQL scripts and parameters.

func JoinSQLEmpty 

func JoinSQLEmpty(values ...any) *SQL

JoinSQLEmpty Use "" to concatenate multiple SQL scripts and parameters.

func JoinSQLSemicolon 

func JoinSQLSemicolon(values ...any) *SQL

JoinSQLSemicolon Use ";" to concatenate multiple SQL scripts and parameters.

func JoinSQLSpace 

func JoinSQLSpace(values ...any) *SQL

JoinSQLSpace Use " " to concatenate multiple SQL scripts and parameters.

func Max 

func Max(values ...any) *SQL

func Min 

func Min(values ...any) *SQL

func NewEmptySQL 

func NewEmptySQL() *SQL

func NewSQL 

func NewSQL(prepare string, args ...any) *SQL

func ParcelCancelSQL 

func ParcelCancelSQL(script *SQL) *SQL

ParcelCancelSQL Cancel parcel the SQL statement. ( `subquery` ) => `subquery` OR ( ( `subquery` ) ) => ( `subquery` )

func ParcelSQL 

func ParcelSQL(script *SQL) *SQL

ParcelSQL Parcel the SQL statement. `subquery` => ( `subquery` )

func RowsTable 

func RowsTable(columns []string, rows func() [][]any, table func(values ...*SQL) *SQL) *SQL

RowsTable Concatenate one or more objects into a SQL table statement. ["id", "name"] + [{"id":1,"name":"name1"}, {"id":2,"name":"name2"}, {"id":3,"name":"name3"} ... ] ==> [( SELECT 1 AS id, NULL AS name ) + ( SELECT 2, 'name2' ) + ( SELECT NULL, 'name3' ) ... ]

func Sum 

func Sum(values ...any) *SQL

func UnionAllSQL 

func UnionAllSQL(scripts ...*SQL) *SQL

UnionAllSQL *SQL1, *SQL2, *SQL3 ... => ( QUERY_A ) UNION ALL ( QUERY_B ) UNION ALL ( QUERY_C )...

func UnionSQL 

func UnionSQL(scripts ...*SQL) *SQL

UnionSQL *SQL1, *SQL2, *SQL3 ... => ( QUERY_A ) UNION ( QUERY_B ) UNION ( QUERY_C )...

func (*SQL) Clone 

func (s *SQL) Clone() *SQL

Clone For clone the current object.

func (*SQL) IsEmpty 

func (s *SQL) IsEmpty() bool

IsEmpty Used to determine whether the current SQL fragments or SQL statements is empty string.

func (*SQL) ToEmpty 

func (s *SQL) ToEmpty() *SQL

ToEmpty Set Prepare, Args to empty value.

func (*SQL) ToSQL 

func (s *SQL) ToSQL() *SQL

ToSQL Implementing the Maker interface.

type SQLAlias 

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
}

SQLAlias SQL script + alias name.

func Alias 

func Alias(script any, aliases ...string) SQLAlias

type SQLCase 

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
}

SQLCase Implementing SQL CASE.

func NewSQLCase 

func NewSQLCase(way *Way) SQLCase

type SQLComment 

type SQLComment interface {
	Maker

	ToEmpty

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

SQLComment Constructing SQL statement comments.

type SQLGroupBy 

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
}

SQLGroupBy Build GROUP BY statements.

type SQLInsert 

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

	// CreateOne value of creation should be one of struct{}, *struct{}, map[string]any.
	// Return the id value of the inserted data.
	CreateOne(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
}

SQLInsert Build INSERT statements.

type SQLJoin 

type SQLJoin interface {
	Maker

	ToEmpty

	// GetMaster Get join query the master table.
	GetMaster() SQLAlias

	// SetMaster Set join query the master table.
	SetMaster(table SQLAlias) SQLJoin

	// NewTable Create a table for join query.
	NewTable(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

	// TableColumn Create a table name prefix for the query column.
	TableColumn(table SQLAlias, column string, aliases ...string) string

	// TableColumns Add table name prefix to the query column list values.
	TableColumns(table SQLAlias, columns ...string) []string
}

SQLJoin Build a join query.

type SQLJoinAssoc 

type SQLJoinAssoc func(table1alias string, table2alias string) SQLJoinOn

type 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
}

SQLJoinOn Construct the connection query conditions.

type SQLLimit 

type SQLLimit interface {
	Maker

	ToEmpty

	IsEmpty() bool

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

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

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

	// DirectLimit Directly use the effective limit value, unaffected by the configured maximum.
	DirectLimit(limit int64) SQLLimit

	// DirectOffset Directly use the effective offset value, unaffected by the configured maximum.
	DirectOffset(offset int64) SQLLimit

	// DirectPage Directly use the effective limit and offset value, unaffected by the configured maximum.
	DirectPage(page int64, pageSize ...int64) SQLLimit
}

SQLLimit Build LIMIT n[ OFFSET m] or OFFSET m ROWS FETCH NEXT n ROWS ONLY statements.

func NewOffsetRowsFetchNextRowsOnly 

func NewOffsetRowsFetchNextRowsOnly(way *Way) SQLLimit

type SQLOnConflict 

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
}

SQLOnConflict Implement the following SQL statement: INSERT INTO ... ON CONFLICT (column_a[, column_b, column_c...]) DO NOTHING /* If a conflict occurs, the insert operation is ignored. */ INSERT INTO ... ON CONFLICT (column_a[, column_b, column_c...]) DO UPDATE SET column1 = EXCLUDED.column1, column2 = EXCLUDED.column2, column3 = EXCLUDED.column3, column4 = 'fixed value' ... /* If a conflict occurs, the existing row is updated with the new value */

type SQLOnConflictUpdateSet 

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
}

SQLOnConflictUpdateSet Implement the following SQL statement: INSERT INTO ... ON CONFLICT ( column_a[, column_b, column_c...] ) DO UPDATE SET column1 = EXCLUDED.column1, column2 = EXCLUDED.column2, column3 = EXCLUDED.column3, column4 = 'fixed value' ...

type SQLOrderBy 

type SQLOrderBy interface {
	Maker

	ToEmpty

	// Num Number of sorted columns used.
	Num() int

	// IsEmpty Is there a list of sorting columns?
	IsEmpty() bool

	// Allow the list of columns that can be used for sorting.
	Allow(columns ...string) SQLOrderBy

	// Replace The column name that may be used.
	Replace(dst string, src string) SQLOrderBy

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

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

	// OrderString Automatically call sorting based on the sort string format.
	OrderString(order *string) SQLOrderBy
}

SQLOrderBy Build ORDER BY statements.

type SQLReturning 

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

	// LastInsertId The driver returns the id value of the inserted data.
	LastInsertId() func(ctx context.Context, stmt *Stmt, args ...any) (lastInsertId int64, err error)

	// QueryRowScan Return values from QueryRow scan for inserted data.
	QueryRowScan(dest ...any) func(ctx context.Context, stmt *Stmt, args ...any) (int64, error)

	// RowsAffected Returns the number of rows affected directly.
	RowsAffected() func(ctx context.Context, stmt *Stmt, args ...any) (rowsAffected int64, err error)

	// 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
}

SQLReturning Build INSERT INTO xxx RETURNING xxx

type SQLSelect 

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
}

SQLSelect Build the query column set.

type SQLUpdateSet 

type SQLUpdateSet interface {
	Maker

	ToEmpty

	IsEmpty() bool

	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

	// 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
}

SQLUpdateSet Build UPDATE-SET statements.

type SQLValues 

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
}

SQLValues Build INSERT-VALUES statements.

type SQLWindow 

type SQLWindow interface {
	Maker

	ToEmpty

	// Set Setting window expression.
	Set(alias string, maker func(o SQLWindowFuncOver)) SQLWindow

	// Del Removing window expression.
	Del(alias string) SQLWindow
}

type SQLWindowFuncFrame 

type SQLWindowFuncFrame interface {
	Maker

	// Script Custom SQL statement.
	Script(maker Maker) 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
}

SQLWindowFuncFrame Define a window based on a start and end, the end position can be omitted and SQL defaults to the current row. Allows independent use of custom SQL statements and parameters as values for GROUPS, ROWS or RANGE statements.

func NewSQLWindowFuncFrame 

func NewSQLWindowFuncFrame(frame string) SQLWindowFuncFrame

type SQLWindowFuncOver 

type SQLWindowFuncOver interface {
	Maker

	ToEmpty

	// Script Custom OVER statement.
	Script(maker Maker) SQLWindowFuncOver

	// Partition The OVER clause defines window partitions so that the window function is calculated independently in each partition.
	Partition(column ...string) SQLWindowFuncOver

	// Asc Define the sorting within the partition so that the window function is calculated in order.
	Asc(column string) SQLWindowFuncOver

	// Desc Define the sorting within the partition so that the window function is calculated in descending order.
	Desc(column string) SQLWindowFuncOver

	// Groups Define the window based on the sort column values.
	Groups(fc func(f SQLWindowFuncFrame)) SQLWindowFuncOver

	// Range Define the window based on the physical row number, accurately control the number of rows (such as the first 2 rows and the last 3 rows).
	Range(fc func(f SQLWindowFuncFrame)) SQLWindowFuncOver

	// Rows Defines a window based on a range of values, including all rows with the same ORDER BY column value; suitable for handling scenarios with equal values (such as time ranges).
	Rows(fc func(f SQLWindowFuncFrame)) SQLWindowFuncOver
}

func NewSQLWindowFuncOver 

func NewSQLWindowFuncOver(way *Way) SQLWindowFuncOver

type SQLWith 

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
}

SQLWith CTE: Common Table Expression.

type Stmt 

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

Stmt Prepare a handle.

func (*Stmt) Close 

func (s *Stmt) Close() (err error)

Close -> Close prepare a handle.

func (*Stmt) Exec 

func (s *Stmt) Exec(ctx context.Context, args ...any) (sql.Result, error)

Exec -> Execute prepared, that can be called repeatedly.

func (*Stmt) Execute 

func (s *Stmt) Execute(ctx context.Context, args ...any) (int64, error)

Execute -> Execute prepared, that can be called repeatedly, return number of rows affected.

func (*Stmt) Query 

func (s *Stmt) Query(ctx context.Context, query func(rows *sql.Rows) error, args ...any) (err error)

Query -> Query prepared, that can be called repeatedly.

func (*Stmt) QueryRow 

func (s *Stmt) QueryRow(ctx context.Context, query func(row *sql.Row) error, args ...any) error

QueryRow -> Query prepared, that can be called repeatedly.

func (*Stmt) Scan 

func (s *Stmt) Scan(ctx context.Context, result any, args ...any) error

Scan -> Query prepared and get all query results, that can be called repeatedly.

type Table 

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

Table Quickly build SELECT, INSERT, UPDATE, DELETE statements and support immediate execution of them.

func (*Table) Alias 

func (s *Table) Alias(alias string) *Table

Alias Set the table alias name.

func (*Table) Asc 

func (s *Table) Asc(columns ...string) *Table

Asc Sort ascending.

func (*Table) Comment 

func (s *Table) Comment(comment string) *Table

Comment SQL statement comment.

func (*Table) CommentFunc 

func (s *Table) CommentFunc(fc func(c SQLComment)) *Table

CommentFunc Set comment through func.

func (*Table) Count 

func (s *Table) Count(ctx context.Context, counts ...string) (int64, error)

Count Total number of statistics.

func (*Table) CountScan 

func (s *Table) CountScan(ctx context.Context, result any, counts ...string) (count int64, err error)

CountScan Merge statistics and scan data.

func (*Table) Create 

func (s *Table) Create(ctx context.Context, create any) (int64, error)

Create Quickly insert data into the table.

func (*Table) CreateOne added in v6.1.2 

func (s *Table) CreateOne(ctx context.Context, create any) (id int64, err error)

CreateOne Quickly insert a piece of data into the table and return the inserted data's id value.

func (*Table) Delete 

func (s *Table) Delete(ctx context.Context) (int64, error)

Delete Execute a DELETE statement.

func (*Table) Desc 

func (s *Table) Desc(columns ...string) *Table

Desc Sort descending.

func (*Table) Distinct 

func (s *Table) Distinct() *Table

Distinct SQL DISTINCT columns.

func (*Table) Exists 

func (s *Table) Exists(ctx context.Context, exists ...func(script *SQL)) (bool, error)

Exists Check if the data exists, allow replacing or updating the subquery script of EXISTS.

func (*Table) F 

func (s *Table) F(filters ...Filter) Filter

F Quickly create a Filter.

func (*Table) Group 

func (s *Table) Group(groups ...any) *Table

Group Set GROUP BY condition.

func (*Table) GroupFunc 

func (s *Table) GroupFunc(fc func(g SQLGroupBy)) *Table

GroupFunc Set GROUP BY through func.

func (*Table) Having 

func (s *Table) Having(filters ...Filter) *Table

Having Set the HAVING condition.

func (*Table) HavingFunc 

func (s *Table) HavingFunc(fc func(h Filter)) *Table

HavingFunc Set HAVING through func.

func (*Table) InnerJoin 

func (s *Table) InnerJoin(fc func(j SQLJoin) (left SQLAlias, right SQLAlias, assoc SQLJoinAssoc)) *Table

InnerJoin INNER JOIN.

func (*Table) Insert 

func (s *Table) Insert(ctx context.Context) (int64, error)

Insert Execute an INSERT INTO statement.

func (*Table) InsertFunc 

func (s *Table) InsertFunc(fc func(i SQLInsert)) *Table

InsertFunc Set inserting data through func.

func (*Table) JoinFunc 

func (s *Table) JoinFunc(fc func(j SQLJoin)) *Table

JoinFunc Custom join query.

func (*Table) LargerCreate 

func (s *Table) LargerCreate(ctx context.Context, batchSize int, create any, prefix func(i SQLInsert), suffix func(i SQLInsert)) (affectedRows int64, err error)

LargerCreate Split a large slice of data into multiple smaller slices and insert them in batches.

func (*Table) LeftJoin 

func (s *Table) LeftJoin(fc func(j SQLJoin) (left SQLAlias, right SQLAlias, assoc SQLJoinAssoc)) *Table

LeftJoin LEFT JOIN.

func (*Table) Limit 

func (s *Table) Limit(limit int64) *Table

Limit Set the maximum number of query result sets.

func (*Table) LimitFunc 

func (s *Table) LimitFunc(fc func(o SQLLimit)) *Table

LimitFunc Set LIMIT x [OFFSET x] through func.

func (*Table) Limiter 

func (s *Table) Limiter(limiter Limiter) *Table

Limiter Set limit and offset at the same time.

func (*Table) MapScan 

func (s *Table) MapScan(ctx context.Context, adjusts ...AdjustColumnAnyValue) ([]map[string]any, error)

MapScan Scanning the query results into []map[string]any.

func (*Table) Modify 

func (s *Table) Modify(ctx context.Context, modify any) (int64, error)

Modify Quickly update data in the table.

func (*Table) Offset 

func (s *Table) Offset(offset int64) *Table

Offset Set the offset of the query target data.

func (*Table) OrderFunc 

func (s *Table) OrderFunc(fc func(o SQLOrderBy)) *Table

OrderFunc Set ORDER BY through func.

func (*Table) OrderString 

func (s *Table) OrderString(order *string) *Table

OrderString Set ORDER BY columns through *string.

func (*Table) Page 

func (s *Table) Page(page int64, pageSize ...int64) *Table

Page Pagination query, page and pageSize.

func (*Table) Query 

func (s *Table) Query(ctx context.Context, query func(rows *sql.Rows) error) error

Query Execute a SELECT statement.

func (*Table) RightJoin 

func (s *Table) RightJoin(fc func(j SQLJoin) (left SQLAlias, right SQLAlias, assoc SQLJoinAssoc)) *Table

RightJoin RIGHT JOIN.

func (*Table) Scan 

func (s *Table) Scan(ctx context.Context, result any) error

Scan Scanning data into result by reflect.

func (*Table) Select 

func (s *Table) Select(columns ...any) *Table

Select Add one or more query lists. If no parameter is provided, all existing query lists will be deleted.

func (*Table) SelectFunc 

func (s *Table) SelectFunc(fc func(q SQLSelect)) *Table

SelectFunc Set SELECT through func.

func (*Table) Table 

func (s *Table) Table(table any) *Table

Table Set the table name, or possibly a subquery with an alias.

func (*Table) TableFunc 

func (s *Table) TableFunc(fc func(t SQLAlias)) *Table

TableFunc Set query table through func.

func (*Table) ToCount 

func (s *Table) ToCount(counts ...string) *SQL

ToCount Build COUNT-SELECT statement.

func (*Table) ToDelete 

func (s *Table) ToDelete() *SQL

ToDelete Build DELETE statement.

func (*Table) ToEmpty 

func (s *Table) ToEmpty() *Table

ToEmpty Do not reset table.

func (*Table) ToExists 

func (s *Table) ToExists(exists ...func(script *SQL)) *SQL

ToExists Build SELECT EXISTS statement, allow replacing or updating the subquery script of EXISTS.

func (*Table) ToInsert 

func (s *Table) ToInsert() *SQL

ToInsert Build INSERT statement.

func (*Table) ToSQL 

func (s *Table) ToSQL() *SQL

ToSQL Implementing the Maker interface using query statement.

func (*Table) ToSelect 

func (s *Table) ToSelect() *SQL

ToSelect Build SELECT statement.

func (*Table) ToUpdate 

func (s *Table) ToUpdate() *SQL

ToUpdate Build UPDATE statement.

func (*Table) Update 

func (s *Table) Update(ctx context.Context) (int64, error)

Update Execute an UPDATE statement.

func (*Table) UpdateFunc 

func (s *Table) UpdateFunc(fc func(f Filter, u SQLUpdateSet)) *Table

UpdateFunc Set updating data through func.

func (*Table) V 

func (s *Table) V() *Way

V Get the currently used *Way object.

func (*Table) W 

func (s *Table) W(way *Way)

W Use *Way given a non-nil value.

func (*Table) Where 

func (s *Table) Where(filters ...Filter) *Table

Where Set the WHERE condition.

func (*Table) WhereFunc 

func (s *Table) WhereFunc(fc func(f Filter)) *Table

WhereFunc Set WHERE through func.

func (*Table) Window 

func (s *Table) Window(alias string, maker func(o SQLWindowFuncOver)) *Table

Window Add a window expression.

func (*Table) WindowFunc 

func (s *Table) WindowFunc(fc func(w SQLWindow)) *Table

WindowFunc Custom window statements.

func (*Table) With 

func (s *Table) With(alias string, maker Maker, columns ...string) *Table

With Add a common table expression.

func (*Table) WithFunc 

func (s *Table) WithFunc(fc func(w SQLWith)) *Table

WithFunc Custom common table expression (CTE).

type TableColumn 

type TableColumn interface {
	// Table Get the current table name.
	Table() string

	// Column Add table name prefix to single column name, allowing column alias to be set.
	Column(column string, alias ...string) string

	// ColumnAll Add table name prefix to column names in batches.
	ColumnAll(columnAll ...string) []string

	// ColumnSQL Single column to *SQL.
	ColumnSQL(column string, alias ...string) *SQL

	// ColumnAllSQL Multiple columns to *SQL.
	ColumnAllSQL(columnAll ...string) *SQL
}

TableColumn Add the prefix "table_name." before the column name. Allow the table name to be empty, which makes it possible to replace column names or construct SQL statements based on column names.

func NewTableColumn 

func NewTableColumn(way *Way, tableName ...string) TableColumn

type TableNamer 

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

TableNamer Generic interface for getting table name.

type TimeFilter 

type TimeFilter interface {
	Timestamp(timestamp int64) TimeFilter

	TimeLocation(location *time.Location) TimeFilter

	LastMinutes(column string, minutes int) TimeFilter

	LastHours(column string, hours int) TimeFilter

	Today(column string) TimeFilter

	Yesterday(column string) TimeFilter

	LastDays(column string, days int) TimeFilter

	ThisMonth(column string) TimeFilter

	LastMonth(column string) TimeFilter

	LastMonths(column string, months int) TimeFilter

	ThisQuarter(column string) TimeFilter

	LastQuarter(column string) TimeFilter

	LastQuarters(column string, quarters int) TimeFilter

	ThisYear(column string) TimeFilter

	LastYear(column string) TimeFilter

	LastYears(column string, years int) TimeFilter
}

TimeFilter Commonly used timestamp range filtering conditions.

type ToEmpty 

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

ToEmpty Sets the property value of an object to empty value.

type Track 

type Track interface {
	Track(ctx context.Context, track any)
}

Track Tracing SQL statements.

type V 

type V interface {
	// V Get the currently used *Way object value.
	V() *Way
}

V Get the currently used *Way object value.

type W 

type W interface {
	// W Use the non-nil value *Way.
	W(way *Way)
}

W Use the non-nil value *Way.

type Way 

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

func ContextWay 

func ContextWay(ctx context.Context, defaultWay *Way) *Way

ContextWay Try to extract *Way from the context.

func NewWay 

func NewWay(options ...Option) *Way

func (*Way) Alias 

func (s *Way) Alias(script any, aliases ...string) SQLAlias

func (*Way) Begin 

func (s *Way) Begin(ctx context.Context, opts ...*sql.TxOptions) (*Way, error)

Begin -> Open transaction.

func (*Way) BeginConn 

func (s *Way) BeginConn(ctx context.Context, conn *sql.Conn, opts ...*sql.TxOptions) (*Way, error)

BeginConn -> Open transaction using *sql.Conn.

func (*Way) Case 

func (s *Way) Case() SQLCase

func (*Way) Commit 

func (s *Way) Commit() error

Commit -> Transaction commit.

func (*Way) Database 

func (s *Way) Database() *sql.DB

func (*Way) Debug 

func (s *Way) Debug(maker Maker) *Way

Debug Debugging output SQL script.

func (*Way) Exec 

func (s *Way) Exec(ctx context.Context, maker Maker) (result sql.Result, err error)

Exec -> Execute the execute sql statement.

func (*Way) Execute 

func (s *Way) Execute(ctx context.Context, maker Maker) (affectedRows int64, err error)

Execute -> Execute the execute sql statement.

func (*Way) Exists 

func (s *Way) Exists(ctx context.Context, maker Maker) (bool, error)

Exists -> Execute a query SQL statement to check if the data exists.

func (*Way) F 

func (s *Way) F(filters ...Filter) Filter

F -> Quickly initialize a filter.

func (*Way) Func 

func (s *Way) Func(funcName string, funcArgs ...any) *SQL

func (*Way) GroupMultiStmtExecute 

func (s *Way) GroupMultiStmtExecute(ctx context.Context, executes []Maker) (affectedRows int64, err error)

GroupMultiStmtExecute Call using the same prepared statement. Multi-statement insert and update.

func (*Way) GroupMultiStmtScan 

func (s *Way) GroupMultiStmtScan(ctx context.Context, queries []Maker, results []any) (err error)

GroupMultiStmtScan Call using the same prepared statement. Multi-statement query.

func (*Way) IsInTransaction 

func (s *Way) IsInTransaction() bool

IsInTransaction -> Is the transaction currently in progress?

func (*Way) IsRead 

func (s *Way) IsRead() bool

IsRead -> Is an object for read?

func (*Way) Manual 

func (s *Way) Manual() *Manual

func (*Way) MapScan 

func (s *Way) MapScan(ctx context.Context, maker Maker, adjusts ...AdjustColumnAnyValue) (result []map[string]any, err error)

MapScan -> Scanning the query results into []map[string]any.

func (*Way) MultiExecute 

func (s *Way) MultiExecute(ctx context.Context, makers []Maker) (affectedRows int64, err error)

MultiExecute Execute multiple DML statements.

func (*Way) MultiScan 

func (s *Way) MultiScan(ctx context.Context, makers []Maker, results []any) (err error)

MultiScan Execute multiple DQL statements.

func (*Way) MultiStmtExecute 

func (s *Way) MultiStmtExecute(ctx context.Context, prepare string, lists [][]any) (affectedRows int64, err error)

MultiStmtExecute Executing a DML statement multiple times using the same prepared statement.

func (*Way) MultiStmtScan 

func (s *Way) MultiStmtScan(ctx context.Context, prepare string, lists [][]any, results []any) (err error)

MultiStmtScan Executing a DQL statement multiple times using the same prepared statement.

func (*Way) MyDelete 

func (s *Way) MyDelete(table string) MyDelete

func (*Way) MyHidden 

func (s *Way) MyHidden(table string, update func(u SQLUpdateSet)) MyHidden

func (*Way) MyInsert 

func (s *Way) MyInsert(table string) MyInsert

func (*Way) MyMulti 

func (s *Way) MyMulti() MyMulti

func (*Way) MySchema 

func (s *Way) MySchema(table string, columns []string) MySchema

func (*Way) MySelect 

func (s *Way) MySelect(table string, columns []string) MySelect

func (*Way) MyUpdate 

func (s *Way) MyUpdate(table string) MyUpdate

func (*Way) Now 

func (s *Way) Now() time.Time

Now -> Get current time, the transaction open status will get the same time.

func (*Way) Prepare 

func (s *Way) Prepare(ctx context.Context, query string) (stmt *Stmt, err error)

Prepare -> Prepare SQL statement, remember to call *Stmt.Close().

func (*Way) Query 

func (s *Way) Query(ctx context.Context, maker Maker, query func(rows *sql.Rows) error) (err error)

Query -> Execute the query sql statement.

func (*Way) QueryRow 

func (s *Way) QueryRow(ctx context.Context, maker Maker, query func(row *sql.Row) error) (err error)

QueryRow -> Execute SQL statement and return row data, usually INSERT, UPDATE, DELETE.

func (*Way) Read 

func (s *Way) Read() *Way

func (*Way) Reader 

func (s *Way) Reader() Reader

func (*Way) Replace 

func (s *Way) Replace(key string) string

Replace Get a single identifier mapping value, if it does not exist, return the original value.

func (*Way) ReplaceAll 

func (s *Way) ReplaceAll(keys []string) []string

ReplaceAll Get multiple identifier mapping values, return the original value if none exists.

func (*Way) Rollback 

func (s *Way) Rollback() error

Rollback -> Transaction rollback.

func (*Way) RowScan 

func (s *Way) RowScan(dest ...any) func(row *sql.Row) error

RowScan Scan a row of SQL results containing one or more columns.

func (*Way) Scan 

func (s *Way) Scan(ctx context.Context, maker Maker, result any) error

Scan -> Query prepared and get all query results, through the mapping of column names and struct tags.

func (*Way) T 

func (s *Way) T(tableName ...string) TableColumn

T Register a shortcut method T to quickly create a TableColumn instance.

func (*Way) Table 

func (s *Way) Table(table any) *Table

Table Create a *Table object to execute SELECT, INSERT, UPDATE, and DELETE statements.

func (*Way) Transaction 

func (s *Way) Transaction(ctx context.Context, fc func(tx *Way) error, opts ...*sql.TxOptions) error

Transaction -> Atomically executes a set of SQL statements. If a transaction has been opened, the opened transaction instance will be used.

func (*Way) TransactionMessage 

func (s *Way) TransactionMessage(message string) *Way

TransactionMessage -> Set the prompt for the current transaction, can only be set once.

func (*Way) TransactionNew 

func (s *Way) TransactionNew(ctx context.Context, fc func(tx *Way) error, opts ...*sql.TxOptions) error

TransactionNew -> Starts a new transaction and executes a set of SQL statements atomically. Does not care whether the current transaction instance is open.

func (*Way) TransactionRetry 

func (s *Way) TransactionRetry(ctx context.Context, retries int, fc func(tx *Way) error, opts ...*sql.TxOptions) (err error)

TransactionRetry Starts a new transaction and executes a set of SQL statements atomically. Does not care whether the current transaction instance is open.

func (*Way) W 

func (s *Way) W(way *Way) *Way

W -> Prioritize the specified non-nil object, otherwise use the current object.

func (*Way) WindowFunc 

func (s *Way) WindowFunc(alias string) *WindowFunc

type WindowFunc 

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

WindowFunc SQL window function.

func NewWindowFunc 

func NewWindowFunc(way *Way, aliases ...string) *WindowFunc

func (*WindowFunc) Alias 

func (s *WindowFunc) Alias(alias string) *WindowFunc

Alias Set the alias of the column that uses the window function.

func (*WindowFunc) Avg 

func (s *WindowFunc) Avg(column string) *WindowFunc

Avg AVG() Returns the average of all rows in the window.

func (*WindowFunc) Count 

func (s *WindowFunc) Count(columns ...string) *WindowFunc

Count COUNT() Returns the number of rows in the window.

func (*WindowFunc) CumeDist 

func (s *WindowFunc) CumeDist() *WindowFunc

CumeDist CUME_DIST()

func (*WindowFunc) DenseRank 

func (s *WindowFunc) DenseRank() *WindowFunc

DenseRank DENSE_RANK() Similar to RANK(), but does not skip rankings.

func (*WindowFunc) FirstValue 

func (s *WindowFunc) FirstValue(column string) *WindowFunc

FirstValue FIRST_VALUE() Returns the value of the first row in the window.

func (*WindowFunc) Lag 

func (s *WindowFunc) Lag(column string, args ...any) *WindowFunc

Lag LAG() Returns the value of the row before the current row.

func (*WindowFunc) LastValue 

func (s *WindowFunc) LastValue(column string) *WindowFunc

LastValue LAST_VALUE() Returns the value of the last row in the window.

func (*WindowFunc) Lead 

func (s *WindowFunc) Lead(column string, args ...any) *WindowFunc

Lead LEAD() Returns the value of a row after the current row.

func (*WindowFunc) Max 

func (s *WindowFunc) Max(column string) *WindowFunc

Max MAX() Returns the maximum value within the window.

func (*WindowFunc) Min 

func (s *WindowFunc) Min(column string) *WindowFunc

Min MIN() Returns the minimum value within the window.

func (*WindowFunc) NTile 

func (s *WindowFunc) NTile(buckets int64, args ...any) *WindowFunc

NTile N-TILE Divide the rows in the window into n buckets and assign a bucket number to each row.

func (*WindowFunc) NthValue 

func (s *WindowFunc) NthValue(column string, args ...any) *WindowFunc

NthValue NTH_VALUE() The Nth value can be returned according to the specified order. This is very useful when you need to get data at a specific position.

func (*WindowFunc) Over 

func (s *WindowFunc) Over(prepare string, args ...any) *WindowFunc

Over Define the OVER clause.

func (*WindowFunc) OverFunc 

func (s *WindowFunc) OverFunc(fc func(o SQLWindowFuncOver)) *WindowFunc

OverFunc Define the OVER clause.

func (*WindowFunc) PercentRank 

func (s *WindowFunc) PercentRank() *WindowFunc

PercentRank PERCENT_RANK()

func (*WindowFunc) Rank 

func (s *WindowFunc) Rank() *WindowFunc

Rank RANK() Assign a rank to each row, if there are duplicate values, the rank is skipped.

func (*WindowFunc) RowNumber 

func (s *WindowFunc) RowNumber() *WindowFunc

RowNumber ROW_NUMBER() Assign a unique serial number to each row, in the order specified, starting with 1.

func (*WindowFunc) Sum 

func (s *WindowFunc) Sum(column string) *WindowFunc

Sum SUM() Returns the sum of all rows in the window.

func (*WindowFunc) ToSQL 

func (s *WindowFunc) ToSQL() *SQL

func (*WindowFunc) WindowFunc 

func (s *WindowFunc) WindowFunc(funcName string, funcArgs ...any) *WindowFunc

WindowFunc Using custom function. for example: CUME_DIST(), PERCENT_RANK(), PERCENTILE_CONT(), PERCENTILE_DISC()...

Source Files

View all Source files

Directories

Path Synopsis

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.