Redis Search

type ProductEntity struct {
    ID        uint64                             `orm:"redisSearch=search"`
    Name      string                             `orm:"required;searchable"`
    Price     float64                            `orm:"searchable;sortable"`
    Stock     uint32                             `orm:"searchable;sortable"`
    Status    string                             `orm:"enum=active,inactive;required;searchable"`
    Category  fluxaorm.Reference[CategoryEntity] `orm:"searchable"`
    Discount  *int32                             `orm:"searchable"`
    CreatedAt time.Time                          `orm:"searchable;sortable"`
}

entities.ProductEntityProvider.RedisSearchCode()       // "search"
entities.ProductEntityProvider.RedisSearchIndexName()  // "ProductEntity_d6bf3283"
entities.ProductEntityProvider.RedisSearchHashPrefix() // "3056f:h:"

// Iterate every generated provider and pick the search-enabled ones:
for _, p := range entities.AllProviders {
    if sp, ok := p.(fluxaorm.RedisSearchEntityProvider); ok {
        fmt.Println(sp.RedisSearchIndexName())
    }
}

type RedisSearchAlter struct {
    IndexName string
    RedisPool string
    Kind      fluxaorm.AlterKind   // AlterKindAddIndex or AlterKindDropIndex
    Safety    fluxaorm.AlterSafety // AlterSafe or AlterDestructive
}

func (a RedisSearchAlter) IsSafe() bool
func (a RedisSearchAlter) Exec(ctx fluxaorm.Context) error

func GetRedisSearchAlters(ctx fluxaorm.Context) ([]RedisSearchAlter, error)

alters, err := fluxaorm.GetRedisSearchAlters(ctx)
if err != nil {
    panic(err)
}
for _, alter := range alters {
    if !alter.IsSafe() {
        continue // drop stale indexes in a later step
    }
    if err = alter.Exec(ctx); err != nil {
        panic(err)
    }
}

func (p productEntityProvider) ReindexRedisSearch(ctx fluxaorm.Context) error

// 1. create the (new) index
alters, _ := fluxaorm.GetRedisSearchAlters(ctx)
for _, alter := range alters {
    if alter.IsSafe() {
        _ = alter.Exec(ctx)
    }
}
// 2. fill the hashes from MySQL
if err := entities.ProductEntityProvider.ReindexRedisSearch(ctx); err != nil {
    return err
}
// 3. once every instance runs the new code, drop stale indexes
for _, alter := range alters {
    if !alter.IsSafe() {
        _ = alter.Exec(ctx)
    }
}

// entities.ProductEntityProvider.FieldsRedisSearch.Name      fluxaorm.RedisSearchTextField
// entities.ProductEntityProvider.FieldsRedisSearch.Price     fluxaorm.RedisSearchNumericField
// entities.ProductEntityProvider.FieldsRedisSearch.Stock     fluxaorm.RedisSearchUintField
// entities.ProductEntityProvider.FieldsRedisSearch.Status    fluxaorm.RedisSearchTagField
// entities.ProductEntityProvider.FieldsRedisSearch.Category  fluxaorm.RedisSearchUintField
// entities.ProductEntityProvider.FieldsRedisSearch.Discount  fluxaorm.RedisSearchIntField
// entities.ProductEntityProvider.FieldsRedisSearch.CreatedAt fluxaorm.RedisSearchNumericField

f := entities.ProductEntityProvider.FieldsRedisSearch

f.Stock.Gte(1)                                        // @Stock:[1 +inf]
f.Price.Between(10.5, 99.99)                          // @Price:[10.5 99.99]
f.Discount.Lt(0)                                      // @Discount:[-inf (0]
f.Status.In("active", "pending")                      // @Status:{active|pending}
f.Category.Eq(category.GetID())                       // @Category:[7 7]
f.Name.Match("laptop")                                // @Name:laptop
f.CreatedAt.Gte(float64(since.Unix()))                // time is stored as Unix seconds

query := fluxaorm.NewRedisSearchQuery().
    Filter(
        entities.ProductEntityProvider.FieldsRedisSearch.Status.In("active"),
        entities.ProductEntityProvider.FieldsRedisSearch.Stock.Gte(1),
    ).
    SortByDESC(entities.ProductEntityProvider.FieldsRedisSearch.Price).
    Pager(fluxaorm.NewPager(1, 50))

query.BuildQueryString() // "@Status:{active} @Stock:[1 +inf]"

func (p productEntityProvider) SearchManyInRedis(ctx fluxaorm.Context, query *fluxaorm.RedisSearchQuery) ([]*entities.ProductEntity, error)

products, err := entities.ProductEntityProvider.SearchManyInRedis(ctx,
    fluxaorm.NewRedisSearchQuery().
        Filter(entities.ProductEntityProvider.FieldsRedisSearch.Stock.Gte(1)).
        SortByASC(entities.ProductEntityProvider.FieldsRedisSearch.Price).
        Pager(fluxaorm.NewPager(1, 100)),
)
if err != nil {
    return err
}
for _, product := range products {
    fmt.Printf("%s %.2f\n", product.GetName(), product.GetPrice())
}

func (p productEntityProvider) SearchManyInRedisWithTotal(ctx fluxaorm.Context, query *fluxaorm.RedisSearchQuery) ([]*entities.ProductEntity, int, error)

products, total, err := entities.ProductEntityProvider.SearchManyInRedisWithTotal(ctx,
    fluxaorm.NewRedisSearchQuery().
        Filter(entities.ProductEntityProvider.FieldsRedisSearch.Status.In("active")).
        Pager(fluxaorm.NewPager(1, 100)),
)
fmt.Printf("showing %d of %d products\n", len(products), total)

func (p productEntityProvider) SearchOneInRedis(ctx fluxaorm.Context, query *fluxaorm.RedisSearchQuery) (*entities.ProductEntity, bool, error)

product, found, err := entities.ProductEntityProvider.SearchOneInRedis(ctx,
    fluxaorm.NewRedisSearchQuery().
        Filter(entities.ProductEntityProvider.FieldsRedisSearch.Category.Eq(categoryID)).
        SortByDESC(entities.ProductEntityProvider.FieldsRedisSearch.CreatedAt),
)
if err != nil {
    return err
}
if !found {
    fmt.Println("not found")
}