beeorm

package module
v2.10.2 Latest Latest
Warning

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

 Go to latest Published: Aug 18, 2023 License: MIT Imports: 31 Imported by: 42

README

BeeORM

Golang ORM designed for optimal performance with MySQL and Redis

codecov Go Report Card MIT license

Official documentation

Documentation

Index

Constants

View Source 
const DateFormat = "2006-01-02"
View Source 
const LazyFlushChannelName = "orm-lazy-flush-stream"
View Source 
const LazyFlushGroupName = "orm-lazy-flush-consumer"
View Source 
const StreamGarbageCollectorChannelName = "orm-stream-garbage-collector-stream"
View Source 
const StreamGarbageCollectorGroupName = "orm-garbage-collector-consumer"
View Source 
const TimeFormat = "2006-01-02 15:04:05"

Variables

This section is empty.

Functions

func DisableCacheHashCheck 

func DisableCacheHashCheck()

func LoadByID added in v2.10.2 

func LoadByID[E Entity, I ID](id I, engine Engine, references ...string) (entity E, found bool)

func RunLazyFlushConsumer 

func RunLazyFlushConsumer(engine Engine, garbage bool)

func RunStreamGarbageCollectorConsumer 

func RunStreamGarbageCollectorConsumer(engine Engine)

Types

type Alter 

type Alter struct {
	SQL  string
	Safe bool
	Pool string
}

func (Alter) Exec 

func (a Alter) Exec(engine Engine)

type Bind 

type Bind map[string]interface{}

func (Bind) Get 

func (b Bind) Get(key string) interface{}

type CachedQuery 

type CachedQuery struct{}

type ColumnSchemaDefinition 

type ColumnSchemaDefinition struct {
	ColumnName string
	Definition string
}

type DB 

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

func (*DB) Begin 

func (db *DB) Begin()

func (*DB) Commit 

func (db *DB) Commit()

func (*DB) Exec 

func (db *DB) Exec(query string, args ...interface{}) ExecResult

func (*DB) GetDBClient 

func (db *DB) GetDBClient() DBClient

func (*DB) GetDBClientTX 

func (db *DB) GetDBClientTX() DBClientTX

func (*DB) GetPoolConfig 

func (db *DB) GetPoolConfig() MySQLPoolConfig

func (*DB) IsInTransaction 

func (db *DB) IsInTransaction() bool

func (*DB) Prepare 

func (db *DB) Prepare(query string) (stmt PreparedStmt, close func())

func (*DB) Query 

func (db *DB) Query(query string, args ...interface{}) (rows Rows, close func())

func (*DB) QueryRow 

func (db *DB) QueryRow(query *Where, toFill ...interface{}) (found bool)

func (*DB) Rollback 

func (db *DB) Rollback()

func (*DB) SetMockClientTX 

func (db *DB) SetMockClientTX(mock DBClientTX)

func (*DB) SetMockDBClient 

func (db *DB) SetMockDBClient(mock DBClient)

type DBClient 

type DBClient interface {
	DBClientQuery
	Begin() (*sql.Tx, error)
}

type DBClientQuery 

type DBClientQuery interface {
	Prepare(query string) (*sql.Stmt, error)
	Exec(query string, args ...interface{}) (sql.Result, error)
	ExecContext(ctx context.Context, query string, args ...interface{}) (sql.Result, error)
	QueryRow(query string, args ...interface{}) *sql.Row
	QueryRowContext(ctx context.Context, query string, args ...interface{}) *sql.Row
	Query(query string, args ...interface{}) (*sql.Rows, error)
	QueryContext(ctx context.Context, query string, args ...interface{}) (*sql.Rows, error)
}

type DBClientTX 

type DBClientTX interface {
	DBClientQuery
	Commit() error
	Rollback() error
}

type DuplicatedKeyError 

type DuplicatedKeyError struct {
	Message string
	Index   string
}

func (*DuplicatedKeyError) Error 

func (err *DuplicatedKeyError) Error() string

type Engine 

type Engine interface {
	Clone() Engine
	GetMysql(code ...string) *DB
	GetLocalCache(code ...string) LocalCache
	GetRedis(code ...string) RedisCache
	IsDirty(entity Entity) bool
	GetDirtyBind(entity Entity) (bind Bind, has bool)
	NewFlusher() Flusher
	Flush(entity ...Entity)
	FlushLazy(entity ...Entity)
	FlushWithCheck(entity ...Entity) error
	FlushWithFullCheck(entity ...Entity) error
	Delete(entity ...Entity)
	DeleteLazy(entity ...Entity)
	GetRegistry() ValidatedRegistry
	SearchWithCount(where *Where, pager *Pager, entities interface{}, references ...string) (totalRows int)
	Search(where *Where, pager *Pager, entities interface{}, references ...string)
	SearchIDsWithCount(where *Where, pager *Pager, entity Entity) (results []uint64, totalRows int)
	SearchIDs(where *Where, pager *Pager, entity Entity) []uint64
	SearchOne(where *Where, entity Entity, references ...string) (found bool)
	CachedSearchOne(entity Entity, indexName string, arguments ...interface{}) (found bool)
	CachedSearchOneWithReferences(entity Entity, indexName string, arguments []interface{}, references []string) (found bool)
	CachedSearch(entities interface{}, indexName string, pager *Pager, arguments ...interface{}) (totalRows int)
	CachedSearchIDs(entity Entity, indexName string, pager *Pager, arguments ...interface{}) (totalRows int, ids []uint64)
	CachedSearchCount(entity Entity, indexName string, arguments ...interface{}) int
	CachedSearchWithReferences(entities interface{}, indexName string, pager *Pager, arguments []interface{}, references []string) (totalRows int)
	ClearCacheByIDs(entity Entity, ids ...uint64)
	LoadByID(id uint64, entity Entity, references ...string) (found bool)
	Load(entity Entity, references ...string) (found bool)
	LoadByIDs(ids []uint64, entities interface{}, references ...string) (found bool)
	GetAlters() (alters []Alter)
	GetEventBroker() EventBroker
	RegisterQueryLogger(handler LogHandler, mysql, redis, local bool)
	EnableQueryDebug()
	EnableQueryDebugCustom(mysql, redis, local bool)
	SetPluginOption(plugin, key string, value interface{})
	GetPluginOption(plugin, key string) interface{}
	SetMetaData(key, value string)
	GetMetaData() Meta
	HasRedisLogger() (bool, []LogHandler)
}

func PrepareTables 

func PrepareTables(t *testing.T, registry *Registry, mySQLVersion, redisVersion int, redisNamespace string, entities ...Entity) (engine Engine)

type Entity 

type Entity interface {
	GetID() uint64

	IsLoaded() bool
	SetOnDuplicateKeyUpdate(bind Bind)
	SetField(field string, value interface{}) error
	Clone() Entity
	SetMetaData(key, value string)
	GetMetaData() Meta
	// contains filtered or unexported methods
}

type EntitySchema 

type EntitySchema interface {
	GetTableName() string
	GetEntityName() string
	GetType() reflect.Type
	NewEntity() Entity
	DropTable(engine Engine)
	TruncateTable(engine Engine)
	UpdateSchema(engine Engine)
	UpdateSchemaAndTruncateTable(engine Engine)
	GetMysql(engine Engine) *DB
	GetMysqlPool() string
	GetLocalCache(engine Engine) (cache LocalCache, has bool)
	GetRedisCache(engine Engine) (cache RedisCache, has bool)
	GetReferences() []EntitySchemaReference
	GetColumns() []string
	GetUniqueIndexes() map[string][]string
	GetSchemaChanges(engine Engine) (has bool, alters []Alter)
	GetUsage(registry ValidatedRegistry) map[reflect.Type][]string
	GetTag(field, key, trueValue, defaultValue string) string
	GetPluginOption(plugin, key string) interface{}
	DisableCache(local, redis bool)
}

type EntitySchemaReference added in v2.7.6 

type EntitySchemaReference struct {
	ColumnName string
	FieldPath  []string
	EntityName string
}

type Enum 

type Enum interface {
	GetFields() []string
	GetDefault() string
	Has(value string) bool
	Index(value string) int
}

type Event 

type Event interface {
	Ack()
	ID() string
	Stream() string
	Meta() Meta
	Unserialize(val interface{})
	// contains filtered or unexported methods
}

type EventBroker 

type EventBroker interface {
	Publish(stream string, body interface{}, meta Meta) (id string)
	Consumer(group string) EventsConsumer
	GetStreamsStatistics(stream ...string) []*RedisStreamStatistics
	GetStreamStatistics(stream string) *RedisStreamStatistics
	GetStreamGroupStatistics(stream, group string) *RedisStreamGroupStatistics
}

type EventConsumerHandler 

type EventConsumerHandler func(events []Event)

type EventEntityFlushed 

type EventEntityFlushed interface {
	Type() FlushType
	EntityName() string
	EntityID() uint64
	Before() Bind
	After() Bind
	MetaData() Meta
}

type EventEntityFlushing 

type EventEntityFlushing interface {
	EventEntityFlushed
	SetID(id uint64)
	SetType(t FlushType)
	SetBefore(before Bind)
	SetAfter(before Bind)
	SetMetaData(key, value string)
	SetField(field string, value interface{}) error
}

type EventsConsumer 

type EventsConsumer interface {
	Consume(ctx context.Context, count int, handler EventConsumerHandler) bool
	ConsumeMany(ctx context.Context, nr, count int, handler EventConsumerHandler) bool
	Claim(from, to int)
	SetBlockTime(seconds int)
}

type ExecResult 

type ExecResult interface {
	LastInsertId() uint64
	RowsAffected() uint64
}

type FlushType 

type FlushType int
const (
	Insert FlushType = iota
	Update
	Delete
	InsertUpdate
)

func (FlushType) Is 

func (ft FlushType) Is(target FlushType) bool

func (FlushType) String 

func (ft FlushType) String() string

type Flusher 

type Flusher interface {
	FlusherCacheSetter
	Track(entity ...Entity) Flusher
	Flush()
	FlushWithCheck() error
	FlushWithFullCheck() error
	FlushLazy()
	Clear()
	Delete(entity ...Entity) Flusher
}

type FlusherCacheSetter 

type FlusherCacheSetter interface {
	GetLocalCacheSetter(code ...string) LocalCacheSetter
	GetRedisCacheSetter(code ...string) RedisCacheSetter
	PublishToStream(stream string, body interface{}, meta Meta)
}

type ID added in v2.10.2 

type ID interface {
	int | uint8 | uint16 | uint32 | uint64
}

type IndexSchemaDefinition 

type IndexSchemaDefinition struct {
	Name   string
	Unique bool
	// contains filtered or unexported fields
}

func (*IndexSchemaDefinition) GetColumns 

func (ti *IndexSchemaDefinition) GetColumns() []string

func (*IndexSchemaDefinition) SetColumns 

func (ti *IndexSchemaDefinition) SetColumns(columns []string)

type LazyFlushConsumer 

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

func NewLazyFlushConsumer 

func NewLazyFlushConsumer(engine Engine) *LazyFlushConsumer

func (*LazyFlushConsumer) Digest 

func (r *LazyFlushConsumer) Digest(ctx context.Context) bool

func (*LazyFlushConsumer) RegisterLazyFlushQueryErrorResolver 

func (r *LazyFlushConsumer) RegisterLazyFlushQueryErrorResolver(resolver LazyFlushQueryErrorResolver)

func (*LazyFlushConsumer) SetBlockTime 

func (b *LazyFlushConsumer) SetBlockTime(seconds int)

type LazyFlushQueryErrorResolver 

type LazyFlushQueryErrorResolver func(engine Engine, event EventEntityFlushed, queryError *mysql.MySQLError) error

type LocalCache 

type LocalCache interface {
	LocalCacheSetter
	GetPoolConfig() LocalCachePoolConfig
	GetSet(key interface{}, ttl time.Duration, provider func() interface{}) interface{}
	Get(key interface{}) (value interface{}, ok bool)
	Clear()
	GetObjectsCount() int
}

type LocalCachePoolConfig 

type LocalCachePoolConfig interface {
	GetCode() string
	GetLimit() int
}

type LocalCacheSetter 

type LocalCacheSetter interface {
	Set(key interface{}, value interface{})
	MSet(pairs ...interface{})
	Remove(keys ...interface{})
}

type Lock 

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

func (*Lock) Refresh 

func (l *Lock) Refresh(ctx context.Context, ttl time.Duration) bool

func (*Lock) Release 

func (l *Lock) Release()

func (*Lock) TTL 

func (l *Lock) TTL(ctx context.Context) time.Duration

type Locker 

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

func (*Locker) Obtain 

func (l *Locker) Obtain(ctx context.Context, key string, ttl time.Duration, waitTimeout time.Duration) (lock *Lock, obtained bool)

type LogHandler 

type LogHandler interface {
	Handle(engine Engine, log map[string]interface{})
}

type Meta added in v2.10.0 

type Meta map[string]string

func (Meta) Get added in v2.10.0 

func (m Meta) Get(key string) string

type MockDBClient 

type MockDBClient struct {
	OriginDB            DBClient
	TX                  DBClientTX
	PrepareMock         func(query string) (*sql.Stmt, error)
	ExecMock            func(query string, args ...interface{}) (sql.Result, error)
	ExecContextMock     func(context context.Context, query string, args ...interface{}) (sql.Result, error)
	QueryRowMock        func(query string, args ...interface{}) *sql.Row
	QueryRowContextMock func(ctx context.Context, query string, args ...interface{}) *sql.Row
	QueryMock           func(query string, args ...interface{}) (*sql.Rows, error)
	QueryContextMock    func(ctx context.Context, query string, args ...interface{}) (*sql.Rows, error)
	BeginMock           func() (*sql.Tx, error)
	CommitMock          func() error
	RollbackMock        func() error
}

func (*MockDBClient) Begin 

func (m *MockDBClient) Begin() (*sql.Tx, error)

func (*MockDBClient) Commit 

func (m *MockDBClient) Commit() error

func (*MockDBClient) Exec 

func (m *MockDBClient) Exec(query string, args ...interface{}) (sql.Result, error)

func (*MockDBClient) ExecContext 

func (m *MockDBClient) ExecContext(ctx context.Context, query string, args ...interface{}) (sql.Result, error)

func (*MockDBClient) Prepare 

func (m *MockDBClient) Prepare(query string) (*sql.Stmt, error)

func (*MockDBClient) Query 

func (m *MockDBClient) Query(query string, args ...interface{}) (*sql.Rows, error)

func (*MockDBClient) QueryContext 

func (m *MockDBClient) QueryContext(ctx context.Context, query string, args ...interface{}) (*sql.Rows, error)

func (*MockDBClient) QueryRow 

func (m *MockDBClient) QueryRow(query string, args ...interface{}) *sql.Row

func (*MockDBClient) QueryRowContext 

func (m *MockDBClient) QueryRowContext(ctx context.Context, query string, args ...interface{}) *sql.Row

func (*MockDBClient) Rollback 

func (m *MockDBClient) Rollback() error

type MockLogHandler 

type MockLogHandler struct {
	Logs []map[string]interface{}
}

func (*MockLogHandler) Clear 

func (h *MockLogHandler) Clear()

func (*MockLogHandler) Handle 

func (h *MockLogHandler) Handle(_ Engine, log map[string]interface{})

type MySQLPoolConfig 

type MySQLPoolConfig interface {
	GetCode() string
	GetDatabase() string
	GetDataSourceURI() string
	GetVersion() int
	// contains filtered or unexported methods
}

type MySQLPoolOptions 

type MySQLPoolOptions struct {
	ConnMaxLifetime    time.Duration
	MaxOpenConnections int
	MaxIdleConnections int
}

type ORM 

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

func (*ORM) Clone 

func (orm *ORM) Clone() Entity

func (*ORM) GetID 

func (orm *ORM) GetID() uint64

func (*ORM) GetMetaData 

func (orm *ORM) GetMetaData() Meta

func (*ORM) IsLoaded 

func (orm *ORM) IsLoaded() bool

func (*ORM) SetField 

func (orm *ORM) SetField(field string, value interface{}) error

func (*ORM) SetMetaData 

func (orm *ORM) SetMetaData(key, value string)

func (*ORM) SetOnDuplicateKeyUpdate 

func (orm *ORM) SetOnDuplicateKeyUpdate(bind Bind)

type Pager 

type Pager struct {
	// CurrentPage is the current page number.
	CurrentPage int

	// PageSize is the number of items per page.
	PageSize int
}

Pager represents a paginated list of results.

func NewPager 

func NewPager(currentPage, pageSize int) *Pager

NewPager creates a new Pager with the given page number and page size.

func (*Pager) GetCurrentPage 

func (pager *Pager) GetCurrentPage() int

GetCurrentPage returns the current page number of the Pager.

func (*Pager) GetPageSize 

func (pager *Pager) GetPageSize() int

GetPageSize returns the page size of the Pager.

func (*Pager) IncrementPage 

func (pager *Pager) IncrementPage()

IncrementPage increments the current page number of the Pager.

func (*Pager) String 

func (pager *Pager) String() string

String returns SQL 'LIMIT X,Y'.

type PipeLineBool 

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

func (*PipeLineBool) Result 

func (c *PipeLineBool) Result() bool

type PipeLineGet 

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

func (*PipeLineGet) Result 

func (c *PipeLineGet) Result() (value string, has bool)

type PipeLineInt 

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

func (*PipeLineInt) Result 

func (c *PipeLineInt) Result() int64

type PipeLineString 

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

func (*PipeLineString) Result 

func (c *PipeLineString) Result() string

type Plugin 

type Plugin interface {
	GetCode() string
}

type PluginInterfaceEngineCreated 

type PluginInterfaceEngineCreated interface {
	PluginInterfaceEngineCreated(engine Engine)
}

type PluginInterfaceEntityFlushed 

type PluginInterfaceEntityFlushed interface {
	PluginInterfaceEntityFlushed(engine Engine, event EventEntityFlushed, cacheFlusher FlusherCacheSetter)
}

type PluginInterfaceEntityFlushing 

type PluginInterfaceEntityFlushing interface {
	PluginInterfaceEntityFlushing(engine Engine, event EventEntityFlushing)
}

type PluginInterfaceEntitySearch 

type PluginInterfaceEntitySearch interface {
	PluginInterfaceEntitySearch(engine Engine, schema EntitySchema, where *Where) *Where
}

type PluginInterfaceInitEntitySchema 

type PluginInterfaceInitEntitySchema interface {
	InterfaceInitEntitySchema(schema SettableEntitySchema, registry *Registry) error
}

type PluginInterfaceInitRegistry 

type PluginInterfaceInitRegistry interface {
	PluginInterfaceInitRegistry(registry *Registry)
}

type PluginInterfaceTableSQLSchemaDefinition 

type PluginInterfaceTableSQLSchemaDefinition interface {
	PluginInterfaceTableSQLSchemaDefinition(engine Engine, sqlSchema *TableSQLSchemaDefinition) error
}

type PreparedStmt 

type PreparedStmt interface {
	Exec(args ...any) ExecResult
	Query(args ...any) (rows Rows, close func())
	QueryRow(args []interface{}, toFill ...interface{}) (found bool)
	Close() error
}

type QueryLoggerSource 

type QueryLoggerSource int

type RedisCache 

type RedisCache interface {
	RedisCacheSetter
	GetSet(key string, expiration time.Duration, provider func() interface{}) interface{}
	PipeLine() *RedisPipeLine
	Info(section ...string) string
	GetPoolConfig() RedisPoolConfig
	Get(key string) (value string, has bool)
	Eval(script string, keys []string, args ...interface{}) interface{}
	EvalSha(sha1 string, keys []string, args ...interface{}) (res interface{}, exists bool)
	SetNX(key string, value interface{}, expiration time.Duration) bool
	ScriptExists(sha1 string) bool
	ScriptLoad(script string) string
	LPush(key string, values ...interface{}) int64
	RPush(key string, values ...interface{}) int64
	LLen(key string) int64
	Exists(keys ...string) int64
	Type(key string) string
	LRange(key string, start, stop int64) []string
	LSet(key string, index int64, value interface{})
	RPop(key string) (value string, found bool)
	LRem(key string, count int64, value interface{})
	Ltrim(key string, start, stop int64)
	HSetNx(key, field string, value interface{}) bool
	HDel(key string, fields ...string)

	HMGet(key string, fields ...string) map[string]interface{}

	HGetAll(key string) map[string]string
	HGet(key, field string) (value string, has bool)
	HLen(key string) int64
	HIncrBy(key, field string, incr int64) int64
	IncrBy(key string, incr int64) int64
	Incr(key string) int64
	IncrWithExpire(key string, expire time.Duration) int64
	Expire(key string, expiration time.Duration) bool
	ZAdd(key string, members ...redis.Z) int64
	ZRem(key string, members ...interface{}) int64
	ZRevRange(key string, start, stop int64) []string
	ZRevRangeWithScores(key string, start, stop int64) []redis.Z
	ZRangeWithScores(key string, start, stop int64) []redis.Z
	ZRangeArgs(args redis.ZRangeArgs) []string
	ZCard(key string) int64
	ZCount(key string, min, max string) int64
	ZScore(key, member string) float64
	MGet(keys ...string) []interface{}
	SAdd(key string, members ...interface{}) int64
	SCard(key string) int64
	SPop(key string) (string, bool)
	SPopN(key string, max int64) []string
	XTrim(stream string, maxLen int64) (deleted int64)
	XRange(stream, start, stop string, count int64) []redis.XMessage
	XRevRange(stream, start, stop string, count int64) []redis.XMessage
	XInfoStream(stream string) *redis.XInfoStream
	XInfoGroups(stream string) []redis.XInfoGroup
	XGroupCreate(stream, group, start string) (key string, exists bool)
	XGroupCreateMkStream(stream, group, start string) (key string, exists bool)
	XGroupDestroy(stream, group string) int64
	XRead(a *redis.XReadArgs) []redis.XStream
	XDel(stream string, ids ...string) int64
	XGroupDelConsumer(stream, group, consumer string) int64
	XReadGroup(ctx context.Context, a *redis.XReadGroupArgs) (streams []redis.XStream)
	XPending(stream, group string) *redis.XPending
	XPendingExt(a *redis.XPendingExtArgs) []redis.XPendingExt
	XLen(stream string) int64
	XClaim(a *redis.XClaimArgs) []redis.XMessage
	XClaimJustID(a *redis.XClaimArgs) []string
	XAck(stream, group string, ids ...string) int64
	FlushAll()
	FlushDB()
	GetLocker() *Locker
	Process(ctx context.Context, cmd redis.Cmder) error
	HasNamespace() bool
	GetNamespace() string
	GetCode() string
	RemoveNamespacePrefix(key string) string
	AddNamespacePrefix(key string) string
	// contains filtered or unexported methods
}

type RedisCacheSetter 

type RedisCacheSetter interface {
	Set(key string, value interface{}, expiration time.Duration)
	MSet(pairs ...interface{})
	Del(keys ...string)

	HSet(key string, values ...interface{})
	HDel(key string, keys ...string)
	// contains filtered or unexported methods
}

type RedisPipeLine 

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

func (*RedisPipeLine) Del 

func (rp *RedisPipeLine) Del(key ...string)

func (*RedisPipeLine) Exec 

func (rp *RedisPipeLine) Exec()

func (*RedisPipeLine) Expire 

func (rp *RedisPipeLine) Expire(key string, expiration time.Duration) *PipeLineBool

func (*RedisPipeLine) Get 

func (rp *RedisPipeLine) Get(key string) *PipeLineGet

func (*RedisPipeLine) HDel 

func (rp *RedisPipeLine) HDel(key string, values ...string)

func (*RedisPipeLine) HIncrBy 

func (rp *RedisPipeLine) HIncrBy(key, field string, incr int64) *PipeLineInt

func (*RedisPipeLine) HSet 

func (rp *RedisPipeLine) HSet(key string, values ...interface{})

func (*RedisPipeLine) MSet 

func (rp *RedisPipeLine) MSet(pairs ...interface{})

func (*RedisPipeLine) Set 

func (rp *RedisPipeLine) Set(key string, value interface{}, expiration time.Duration)

func (*RedisPipeLine) XAdd 

func (rp *RedisPipeLine) XAdd(stream string, values []string) *PipeLineString

type RedisPoolConfig 

type RedisPoolConfig interface {
	GetCode() string
	GetDatabase() int
	GetAddress() string
	GetNamespace() string
	HasNamespace() bool
	// contains filtered or unexported methods
}

type RedisStreamConsumerStatistics 

type RedisStreamConsumerStatistics struct {
	Name    string
	Pending uint64
}

type RedisStreamGroupStatistics 

type RedisStreamGroupStatistics struct {
	Group                 string
	Lag                   int64
	Pending               uint64
	LastDeliveredID       string
	LastDeliveredDuration time.Duration
	LowerID               string
	LowerDuration         time.Duration
	Consumers             []*RedisStreamConsumerStatistics
}

type RedisStreamStatistics 

type RedisStreamStatistics struct {
	Stream             string
	RedisPool          string
	Len                uint64
	OldestEventSeconds int
	Groups             []*RedisStreamGroupStatistics
}

type Registry 

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

func NewRegistry 

func NewRegistry() *Registry

func (*Registry) GetDefaultCollate 

func (r *Registry) GetDefaultCollate() string

func (*Registry) HasRegisteredRedisPool added in v2.10.0 

func (r *Registry) HasRegisteredRedisPool(pool string) bool

func (*Registry) InitByYaml 

func (r *Registry) InitByYaml(yaml map[string]interface{})

func (*Registry) RegisterEntity 

func (r *Registry) RegisterEntity(entity ...Entity)

func (*Registry) RegisterEnum 

func (r *Registry) RegisterEnum(code string, values []string, defaultValue ...string)

func (*Registry) RegisterEnumStruct 

func (r *Registry) RegisterEnumStruct(code string, val interface{}, defaultValue ...string)

func (*Registry) RegisterLocalCache 

func (r *Registry) RegisterLocalCache(size int, code ...string)

func (*Registry) RegisterMySQLPool 

func (r *Registry) RegisterMySQLPool(dataSourceName string, poolOptions MySQLPoolOptions, code ...string)

func (*Registry) RegisterMySQLTable 

func (r *Registry) RegisterMySQLTable(pool string, tableName ...string)

func (*Registry) RegisterPlugin 

func (r *Registry) RegisterPlugin(plugin Plugin)

func (*Registry) RegisterRedis 

func (r *Registry) RegisterRedis(address, namespace string, db int, code ...string)

func (*Registry) RegisterRedisSentinel 

func (r *Registry) RegisterRedisSentinel(masterName, namespace string, db int, sentinels []string, code ...string)

func (*Registry) RegisterRedisSentinelWithCredentials 

func (r *Registry) RegisterRedisSentinelWithCredentials(masterName, namespace, user, password string, db int, sentinels []string, code ...string)

func (*Registry) RegisterRedisSentinelWithOptions 

func (r *Registry) RegisterRedisSentinelWithOptions(namespace string, opts redis.FailoverOptions, db int, sentinels []string, code ...string)

func (*Registry) RegisterRedisStream 

func (r *Registry) RegisterRedisStream(name string, redisPool string)

func (*Registry) RegisterRedisStreamConsumerGroups 

func (r *Registry) RegisterRedisStreamConsumerGroups(stream string, groups ...string)

func (*Registry) RegisterRedisWithCredentials 

func (r *Registry) RegisterRedisWithCredentials(address, namespace, user, password string, db int, code ...string)

func (*Registry) SetDefaultCollate 

func (r *Registry) SetDefaultCollate(collate string)

func (*Registry) SetDefaultEncoding 

func (r *Registry) SetDefaultEncoding(encoding string)

func (*Registry) Validate 

func (r *Registry) Validate() (validated ValidatedRegistry, err error)

type Rows 

type Rows interface {
	Next() bool
	Scan(dest ...interface{})
	Columns() []string
}

type SQLRow 

type SQLRow interface {
	Scan(dest ...interface{}) error
}

type SQLRows 

type SQLRows interface {
	Next() bool
	Err() error
	Close() error
	Scan(dest ...interface{}) error
	Columns() ([]string, error)
}

type SettableEntitySchema 

type SettableEntitySchema interface {
	EntitySchema
	SetPluginOption(plugin, key string, value interface{})
}

type StreamGarbageCollectorConsumer 

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

func NewStreamGarbageCollectorConsumer 

func NewStreamGarbageCollectorConsumer(engine Engine) *StreamGarbageCollectorConsumer

func (*StreamGarbageCollectorConsumer) Digest 

func (r *StreamGarbageCollectorConsumer) Digest(ctx context.Context) bool

func (*StreamGarbageCollectorConsumer) SetBlockTime 

func (b *StreamGarbageCollectorConsumer) SetBlockTime(seconds int)

type TableSQLSchemaDefinition 

type TableSQLSchemaDefinition struct {
	EntitySchema   EntitySchema
	EntityColumns  []*ColumnSchemaDefinition
	EntityIndexes  []*IndexSchemaDefinition
	DBTableColumns []*ColumnSchemaDefinition
	DBIndexes      []*IndexSchemaDefinition
	DBCreateSchema string
	DBEncoding     string
	PreAlters      []Alter
	PostAlters     []Alter
	// contains filtered or unexported fields
}

func (*TableSQLSchemaDefinition) CreateTableSQL 

func (td *TableSQLSchemaDefinition) CreateTableSQL() string

type ValidatedRegistry 

type ValidatedRegistry interface {
	CreateEngine() Engine
	GetEntitySchema(entityName string) EntitySchema
	GetEntitySchemaForEntity(entity Entity) EntitySchema
	GetEntitySchemaForCachePrefix(cachePrefix string) EntitySchema
	GetSourceRegistry() *Registry
	GetEnum(code string) Enum
	GetRedisStreams() map[string]map[string][]string
	GetMySQLPools() map[string]MySQLPoolConfig
	GetLocalCachePools() map[string]LocalCachePoolConfig
	GetRedisPools() map[string]RedisPoolConfig
	GetEntities() map[string]reflect.Type
	GetPlugins() []string
	GetPlugin(code string) Plugin
}

type Where 

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

func NewWhere 

func NewWhere(query string, parameters ...interface{}) *Where

func (*Where) Append 

func (where *Where) Append(query string, parameters ...interface{})

func (*Where) GetParameters 

func (where *Where) GetParameters() []interface{}

func (*Where) SetParameter 

func (where *Where) SetParameter(index int, param interface{}) *Where

func (*Where) SetParameters 

func (where *Where) SetParameters(params ...interface{}) *Where

func (*Where) String 

func (where *Where) String() string

Source Files

View all Source files

Directories

Path Synopsis
plugins
crud_stream
fake_delete
foreign_keys
log_table
simple_metrics
uuid

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.