filter_translator

package
v0.1.1 Latest Latest
Warning

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

 Go to latest Published: Aug 19, 2026 License: MIT Imports: 8 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

View Source 
var DefaultGormRegistry = NewGormTranslatorRegistry()

DefaultGormRegistry 默认 GORM 翻译器注册表（全局单例）

View Source 
var DefaultRedisRegistry = NewRedisTranslatorRegistry()

Functions

func ApplyGormFilters 

func ApplyGormFilters(db *gorm.DB, filters []GormFilter) *gorm.DB

ApplyGormFilters 应用多个 GORM 过滤器

func ApplyRedisFilters 

func ApplyRedisFilters(ctx context.Context, client *redis.Client, initialKeys []string, filters []RedisFilter) ([]string, error)

ApplyRedisFilters 外部调用入口

func ValidateSQLIdentifier 

func ValidateSQLIdentifier(name string) error

ValidateSQLIdentifier 校验 SQL 标识符（列名、表名、排序字段等），防止 SQL 注入

Types

type BaseFilter 

type BaseFilter interface {
	GetField() string
	GetValue() interface{}
	GetOperator() string
}

BaseFilter 基础过滤器接口（抽象）

type FilterParam 

type FilterParam struct {
	Field    string      `json:"field"`    // 字段名
	Operator string      `json:"operator"` // 操作符
	Value    interface{} `json:"value"`    // 值
}

FilterParam 前端过滤参数（统一格式）

type FilterTranslator 

type FilterTranslator interface {
	// Translate 将前端参数翻译为通用 Filter 数据
	Translate(param FilterParam) (BaseFilter, error)

	// SupportedOperator 返回支持的操作符
	SupportedOperator() string

	// Validate 验证参数是否合法
	Validate(param FilterParam) error
}

FilterTranslator 过滤器翻译器接口 负责将前端参数翻译为后端 Filter

type GenericBetweenFilter 

type GenericBetweenFilter struct {
	Field    string
	Operator string
	Min      interface{}
	Max      interface{}
}

GenericBetweenFilter BETWEEN 过滤器通用数据

func (*GenericBetweenFilter) GetField 

func (f *GenericBetweenFilter) GetField() string

func (*GenericBetweenFilter) GetOperator 

func (f *GenericBetweenFilter) GetOperator() string

func (*GenericBetweenFilter) GetValue 

func (f *GenericBetweenFilter) GetValue() interface{}

type GenericFilter 

type GenericFilter struct {
	Field    string
	Operator string
	Value    interface{}
}

GenericFilter 通用过滤器（存储过滤器数据）

func (*GenericFilter) GetField 

func (f *GenericFilter) GetField() string

func (*GenericFilter) GetOperator 

func (f *GenericFilter) GetOperator() string

func (*GenericFilter) GetValue 

func (f *GenericFilter) GetValue() interface{}

type GenericInFilter 

type GenericInFilter struct {
	Field    string
	Operator string
	Values   []interface{}
}

GenericInFilter IN 过滤器通用数据

func (*GenericInFilter) GetField 

func (f *GenericInFilter) GetField() string

func (*GenericInFilter) GetOperator 

func (f *GenericInFilter) GetOperator() string

func (*GenericInFilter) GetValue 

func (f *GenericInFilter) GetValue() interface{}

type GormBetweenFilter 

type GormBetweenFilter struct {
	*GenericBetweenFilter
}

GormBetweenFilter BETWEEN 过滤器

func (*GormBetweenFilter) ApplyGorm 

func (f *GormBetweenFilter) ApplyGorm(db *gorm.DB) *gorm.DB

type GormBetweenTranslator 

type GormBetweenTranslator struct{}

GormBetweenTranslator BETWEEN 翻译器

func (*GormBetweenTranslator) SupportedOperator 

func (t *GormBetweenTranslator) SupportedOperator() string

func (*GormBetweenTranslator) Translate 

func (t *GormBetweenTranslator) Translate(param FilterParam) (BaseFilter, error)

func (*GormBetweenTranslator) Validate 

func (t *GormBetweenTranslator) Validate(param FilterParam) error

type GormEqualFilter 

type GormEqualFilter struct {
	*GenericFilter
}

GormEqualFilter 等于过滤器

func (*GormEqualFilter) ApplyGorm 

func (f *GormEqualFilter) ApplyGorm(db *gorm.DB) *gorm.DB

type GormEqualTranslator 

type GormEqualTranslator struct{}

GormEqualTranslator 等于翻译器

func (*GormEqualTranslator) SupportedOperator 

func (t *GormEqualTranslator) SupportedOperator() string

func (*GormEqualTranslator) Translate 

func (t *GormEqualTranslator) Translate(param FilterParam) (BaseFilter, error)

func (*GormEqualTranslator) Validate 

func (t *GormEqualTranslator) Validate(param FilterParam) error

type GormFilter 

type GormFilter interface {
	BaseFilter
	ApplyGorm(db *gorm.DB) *gorm.DB
}

GormFilter GORM 过滤器接口

type GormGreaterThanFilter 

type GormGreaterThanFilter struct {
	*GenericFilter
}

GormGreaterThanFilter 大于过滤器

func (*GormGreaterThanFilter) ApplyGorm 

func (f *GormGreaterThanFilter) ApplyGorm(db *gorm.DB) *gorm.DB

type GormGreaterThanOrEqualFilter 

type GormGreaterThanOrEqualFilter struct {
	*GenericFilter
}

GormGreaterThanOrEqualFilter 大于等于过滤器

func (*GormGreaterThanOrEqualFilter) ApplyGorm 

func (f *GormGreaterThanOrEqualFilter) ApplyGorm(db *gorm.DB) *gorm.DB

type GormGreaterThanOrEqualTranslator 

type GormGreaterThanOrEqualTranslator struct{}

GormGreaterThanOrEqualTranslator 大于等于翻译器

func (*GormGreaterThanOrEqualTranslator) SupportedOperator 

func (t *GormGreaterThanOrEqualTranslator) SupportedOperator() string

func (*GormGreaterThanOrEqualTranslator) Translate 

func (t *GormGreaterThanOrEqualTranslator) Translate(param FilterParam) (BaseFilter, error)

func (*GormGreaterThanOrEqualTranslator) Validate 

func (t *GormGreaterThanOrEqualTranslator) Validate(param FilterParam) error

type GormGreaterThanTranslator 

type GormGreaterThanTranslator struct{}

GormGreaterThanTranslator 大于翻译器

func (*GormGreaterThanTranslator) SupportedOperator 

func (t *GormGreaterThanTranslator) SupportedOperator() string

func (*GormGreaterThanTranslator) Translate 

func (t *GormGreaterThanTranslator) Translate(param FilterParam) (BaseFilter, error)

func (*GormGreaterThanTranslator) Validate 

func (t *GormGreaterThanTranslator) Validate(param FilterParam) error

type GormInFilter 

type GormInFilter struct {
	*GenericInFilter
}

GormInFilter IN 过滤器

func (*GormInFilter) ApplyGorm 

func (f *GormInFilter) ApplyGorm(db *gorm.DB) *gorm.DB

type GormInTranslator 

type GormInTranslator struct{}

GormInTranslator IN 翻译器

func (*GormInTranslator) SupportedOperator 

func (t *GormInTranslator) SupportedOperator() string

func (*GormInTranslator) Translate 

func (t *GormInTranslator) Translate(param FilterParam) (BaseFilter, error)

func (*GormInTranslator) Validate 

func (t *GormInTranslator) Validate(param FilterParam) error

type GormIsNotNullFilter 

type GormIsNotNullFilter struct {
	*GenericFilter
}

GormIsNotNullFilter IS NOT NULL 过滤器

func (*GormIsNotNullFilter) ApplyGorm 

func (f *GormIsNotNullFilter) ApplyGorm(db *gorm.DB) *gorm.DB

type GormIsNotNullTranslator 

type GormIsNotNullTranslator struct{}

GormIsNotNullTranslator IS NOT NULL 翻译器

func (*GormIsNotNullTranslator) SupportedOperator 

func (t *GormIsNotNullTranslator) SupportedOperator() string

func (*GormIsNotNullTranslator) Translate 

func (t *GormIsNotNullTranslator) Translate(param FilterParam) (BaseFilter, error)

func (*GormIsNotNullTranslator) Validate 

func (t *GormIsNotNullTranslator) Validate(param FilterParam) error

type GormIsNullFilter 

type GormIsNullFilter struct {
	*GenericFilter
}

GormIsNullFilter IS NULL 过滤器

func (*GormIsNullFilter) ApplyGorm 

func (f *GormIsNullFilter) ApplyGorm(db *gorm.DB) *gorm.DB

type GormIsNullTranslator 

type GormIsNullTranslator struct{}

GormIsNullTranslator IS NULL 翻译器

func (*GormIsNullTranslator) SupportedOperator 

func (t *GormIsNullTranslator) SupportedOperator() string

func (*GormIsNullTranslator) Translate 

func (t *GormIsNullTranslator) Translate(param FilterParam) (BaseFilter, error)

func (*GormIsNullTranslator) Validate 

func (t *GormIsNullTranslator) Validate(param FilterParam) error

type GormLessThanFilter 

type GormLessThanFilter struct {
	*GenericFilter
}

GormLessThanFilter 小于过滤器

func (*GormLessThanFilter) ApplyGorm 

func (f *GormLessThanFilter) ApplyGorm(db *gorm.DB) *gorm.DB

type GormLessThanOrEqualFilter 

type GormLessThanOrEqualFilter struct {
	*GenericFilter
}

GormLessThanOrEqualFilter 小于等于过滤器

func (*GormLessThanOrEqualFilter) ApplyGorm 

func (f *GormLessThanOrEqualFilter) ApplyGorm(db *gorm.DB) *gorm.DB

type GormLessThanOrEqualTranslator 

type GormLessThanOrEqualTranslator struct{}

GormLessThanOrEqualTranslator 小于等于翻译器

func (*GormLessThanOrEqualTranslator) SupportedOperator 

func (t *GormLessThanOrEqualTranslator) SupportedOperator() string

func (*GormLessThanOrEqualTranslator) Translate 

func (t *GormLessThanOrEqualTranslator) Translate(param FilterParam) (BaseFilter, error)

func (*GormLessThanOrEqualTranslator) Validate 

func (t *GormLessThanOrEqualTranslator) Validate(param FilterParam) error

type GormLessThanTranslator 

type GormLessThanTranslator struct{}

GormLessThanTranslator 小于翻译器

func (*GormLessThanTranslator) SupportedOperator 

func (t *GormLessThanTranslator) SupportedOperator() string

func (*GormLessThanTranslator) Translate 

func (t *GormLessThanTranslator) Translate(param FilterParam) (BaseFilter, error)

func (*GormLessThanTranslator) Validate 

func (t *GormLessThanTranslator) Validate(param FilterParam) error

type GormLikeFilter 

type GormLikeFilter struct {
	*GenericFilter
}

GormLikeFilter 模糊匹配过滤器

func (*GormLikeFilter) ApplyGorm 

func (f *GormLikeFilter) ApplyGorm(db *gorm.DB) *gorm.DB

type GormLikeTranslator 

type GormLikeTranslator struct{}

GormLikeTranslator 模糊匹配翻译器

func (*GormLikeTranslator) SupportedOperator 

func (t *GormLikeTranslator) SupportedOperator() string

func (*GormLikeTranslator) Translate 

func (t *GormLikeTranslator) Translate(param FilterParam) (BaseFilter, error)

func (*GormLikeTranslator) Validate 

func (t *GormLikeTranslator) Validate(param FilterParam) error

type GormNotEqualFilter 

type GormNotEqualFilter struct {
	*GenericFilter
}

GormNotEqualFilter 不等于过滤器

func (*GormNotEqualFilter) ApplyGorm 

func (f *GormNotEqualFilter) ApplyGorm(db *gorm.DB) *gorm.DB

type GormNotEqualTranslator 

type GormNotEqualTranslator struct{}

GormNotEqualTranslator 不等于翻译器

func (*GormNotEqualTranslator) SupportedOperator 

func (t *GormNotEqualTranslator) SupportedOperator() string

func (*GormNotEqualTranslator) Translate 

func (t *GormNotEqualTranslator) Translate(param FilterParam) (BaseFilter, error)

func (*GormNotEqualTranslator) Validate 

func (t *GormNotEqualTranslator) Validate(param FilterParam) error

type GormTranslatorRegistry 

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

GormTranslatorRegistry GORM 翻译器注册表

func NewGormTranslatorRegistry 

func NewGormTranslatorRegistry() *GormTranslatorRegistry

NewGormTranslatorRegistry 创建 GORM 翻译器注册表

func (*GormTranslatorRegistry) GetSupportedOperators 

func (r *GormTranslatorRegistry) GetSupportedOperators() []string

GetSupportedOperators 获取所有支持的操作符

func (*GormTranslatorRegistry) Register 

func (r *GormTranslatorRegistry) Register(translator FilterTranslator)

Register 注册翻译器

func (*GormTranslatorRegistry) Translate 

func (r *GormTranslatorRegistry) Translate(param FilterParam) (GormFilter, error)

Translate 翻译前端参数为 Filter

func (*GormTranslatorRegistry) TranslateBatch 

func (r *GormTranslatorRegistry) TranslateBatch(params []FilterParam) ([]GormFilter, error)

TranslateBatch 批量翻译

type RedisBetweenFilter 

type RedisBetweenFilter struct{ *GenericBetweenFilter }

func (*RedisBetweenFilter) ApplyRedis 

func (f *RedisBetweenFilter) ApplyRedis(ctx context.Context, client *redis.Client, keys []string) ([]string, error)

type RedisBetweenTranslator 

type RedisBetweenTranslator struct{}

func (*RedisBetweenTranslator) SupportedOperator 

func (t *RedisBetweenTranslator) SupportedOperator() string

func (*RedisBetweenTranslator) Translate 

func (t *RedisBetweenTranslator) Translate(param FilterParam) (BaseFilter, error)

func (*RedisBetweenTranslator) Validate 

func (t *RedisBetweenTranslator) Validate(param FilterParam) error

type RedisEqualFilter 

type RedisEqualFilter struct{ *GenericFilter }

func (*RedisEqualFilter) ApplyRedis 

func (f *RedisEqualFilter) ApplyRedis(ctx context.Context, client *redis.Client, keys []string) ([]string, error)

type RedisEqualTranslator 

type RedisEqualTranslator struct{}

func (*RedisEqualTranslator) SupportedOperator 

func (t *RedisEqualTranslator) SupportedOperator() string

func (*RedisEqualTranslator) Translate 

func (t *RedisEqualTranslator) Translate(param FilterParam) (BaseFilter, error)

func (*RedisEqualTranslator) Validate 

func (t *RedisEqualTranslator) Validate(param FilterParam) error

type RedisFilter 

type RedisFilter interface {
	BaseFilter
	// ApplyRedis 应用 Redis 过滤逻辑，返回过滤后的 keys
	ApplyRedis(ctx context.Context, client *redis.Client, keys []string) ([]string, error)
}

type RedisFilterFunc 

type RedisFilterFunc func(value interface{}) bool

RedisFilterFunc 辅助函数类型

type RedisGreaterThanFilter 

type RedisGreaterThanFilter struct{ *GenericFilter }

func (*RedisGreaterThanFilter) ApplyRedis 

func (f *RedisGreaterThanFilter) ApplyRedis(ctx context.Context, client *redis.Client, keys []string) ([]string, error)

type RedisGreaterThanOrEqualFilter 

type RedisGreaterThanOrEqualFilter struct{ *GenericFilter }

func (*RedisGreaterThanOrEqualFilter) ApplyRedis 

func (f *RedisGreaterThanOrEqualFilter) ApplyRedis(ctx context.Context, client *redis.Client, keys []string) ([]string, error)

type RedisGreaterThanOrEqualTranslator 

type RedisGreaterThanOrEqualTranslator struct{}

func (*RedisGreaterThanOrEqualTranslator) SupportedOperator 

func (t *RedisGreaterThanOrEqualTranslator) SupportedOperator() string

func (*RedisGreaterThanOrEqualTranslator) Translate 

func (t *RedisGreaterThanOrEqualTranslator) Translate(param FilterParam) (BaseFilter, error)

func (*RedisGreaterThanOrEqualTranslator) Validate 

func (t *RedisGreaterThanOrEqualTranslator) Validate(param FilterParam) error

type RedisGreaterThanTranslator 

type RedisGreaterThanTranslator struct{}

func (*RedisGreaterThanTranslator) SupportedOperator 

func (t *RedisGreaterThanTranslator) SupportedOperator() string

func (*RedisGreaterThanTranslator) Translate 

func (t *RedisGreaterThanTranslator) Translate(param FilterParam) (BaseFilter, error)

func (*RedisGreaterThanTranslator) Validate 

func (t *RedisGreaterThanTranslator) Validate(param FilterParam) error

type RedisInFilter 

type RedisInFilter struct{ *GenericInFilter }

func (*RedisInFilter) ApplyRedis 

func (f *RedisInFilter) ApplyRedis(ctx context.Context, client *redis.Client, keys []string) ([]string, error)

type RedisInTranslator 

type RedisInTranslator struct{}

func (*RedisInTranslator) SupportedOperator 

func (t *RedisInTranslator) SupportedOperator() string

func (*RedisInTranslator) Translate 

func (t *RedisInTranslator) Translate(param FilterParam) (BaseFilter, error)

func (*RedisInTranslator) Validate 

func (t *RedisInTranslator) Validate(param FilterParam) error

type RedisIsNotNullFilter 

type RedisIsNotNullFilter struct{ *GenericFilter }

func (*RedisIsNotNullFilter) ApplyRedis 

func (f *RedisIsNotNullFilter) ApplyRedis(ctx context.Context, client *redis.Client, keys []string) ([]string, error)

type RedisIsNotNullTranslator 

type RedisIsNotNullTranslator struct{}

func (*RedisIsNotNullTranslator) SupportedOperator 

func (t *RedisIsNotNullTranslator) SupportedOperator() string

func (*RedisIsNotNullTranslator) Translate 

func (t *RedisIsNotNullTranslator) Translate(param FilterParam) (BaseFilter, error)

func (*RedisIsNotNullTranslator) Validate 

func (t *RedisIsNotNullTranslator) Validate(param FilterParam) error

type RedisIsNullFilter 

type RedisIsNullFilter struct{ *GenericFilter }

func (*RedisIsNullFilter) ApplyRedis 

func (f *RedisIsNullFilter) ApplyRedis(ctx context.Context, client *redis.Client, keys []string) ([]string, error)

type RedisIsNullTranslator 

type RedisIsNullTranslator struct{}

func (*RedisIsNullTranslator) SupportedOperator 

func (t *RedisIsNullTranslator) SupportedOperator() string

func (*RedisIsNullTranslator) Translate 

func (t *RedisIsNullTranslator) Translate(param FilterParam) (BaseFilter, error)

func (*RedisIsNullTranslator) Validate 

func (t *RedisIsNullTranslator) Validate(param FilterParam) error

type RedisLessThanFilter 

type RedisLessThanFilter struct{ *GenericFilter }

func (*RedisLessThanFilter) ApplyRedis 

func (f *RedisLessThanFilter) ApplyRedis(ctx context.Context, client *redis.Client, keys []string) ([]string, error)

type RedisLessThanOrEqualFilter 

type RedisLessThanOrEqualFilter struct{ *GenericFilter }

func (*RedisLessThanOrEqualFilter) ApplyRedis 

func (f *RedisLessThanOrEqualFilter) ApplyRedis(ctx context.Context, client *redis.Client, keys []string) ([]string, error)

type RedisLessThanOrEqualTranslator 

type RedisLessThanOrEqualTranslator struct{}

func (*RedisLessThanOrEqualTranslator) SupportedOperator 

func (t *RedisLessThanOrEqualTranslator) SupportedOperator() string

func (*RedisLessThanOrEqualTranslator) Translate 

func (t *RedisLessThanOrEqualTranslator) Translate(param FilterParam) (BaseFilter, error)

func (*RedisLessThanOrEqualTranslator) Validate 

func (t *RedisLessThanOrEqualTranslator) Validate(param FilterParam) error

type RedisLessThanTranslator 

type RedisLessThanTranslator struct{}

func (*RedisLessThanTranslator) SupportedOperator 

func (t *RedisLessThanTranslator) SupportedOperator() string

func (*RedisLessThanTranslator) Translate 

func (t *RedisLessThanTranslator) Translate(param FilterParam) (BaseFilter, error)

func (*RedisLessThanTranslator) Validate 

func (t *RedisLessThanTranslator) Validate(param FilterParam) error

type RedisLikeFilter 

type RedisLikeFilter struct{ *GenericFilter }

func (*RedisLikeFilter) ApplyRedis 

func (f *RedisLikeFilter) ApplyRedis(ctx context.Context, client *redis.Client, keys []string) ([]string, error)

type RedisLikeTranslator 

type RedisLikeTranslator struct{}

func (*RedisLikeTranslator) SupportedOperator 

func (t *RedisLikeTranslator) SupportedOperator() string

func (*RedisLikeTranslator) Translate 

func (t *RedisLikeTranslator) Translate(param FilterParam) (BaseFilter, error)

func (*RedisLikeTranslator) Validate 

func (t *RedisLikeTranslator) Validate(param FilterParam) error

type RedisNotEqualFilter 

type RedisNotEqualFilter struct{ *GenericFilter }

func (*RedisNotEqualFilter) ApplyRedis 

func (f *RedisNotEqualFilter) ApplyRedis(ctx context.Context, client *redis.Client, keys []string) ([]string, error)

type RedisNotEqualTranslator 

type RedisNotEqualTranslator struct{}

func (*RedisNotEqualTranslator) SupportedOperator 

func (t *RedisNotEqualTranslator) SupportedOperator() string

func (*RedisNotEqualTranslator) Translate 

func (t *RedisNotEqualTranslator) Translate(param FilterParam) (BaseFilter, error)

func (*RedisNotEqualTranslator) Validate 

func (t *RedisNotEqualTranslator) Validate(param FilterParam) error

type RedisTranslatorRegistry 

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

func NewRedisTranslatorRegistry 

func NewRedisTranslatorRegistry() *RedisTranslatorRegistry

func (*RedisTranslatorRegistry) Register 

func (r *RedisTranslatorRegistry) Register(translator FilterTranslator)

func (*RedisTranslatorRegistry) Translate 

func (r *RedisTranslatorRegistry) Translate(param FilterParam) (RedisFilter, error)

func (*RedisTranslatorRegistry) TranslateBatch 

func (r *RedisTranslatorRegistry) TranslateBatch(params []FilterParam) ([]RedisFilter, error)

Source Files

View all Source files

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.