mirror of
https://gitlab.com/mbugroup/lti-api.git
synced 2026-05-24 07:15:43 +00:00
.
This commit is contained in:
GitLab Deploy Bot
+825
@@ -0,0 +1,825 @@
|
||||
package redis
|
||||
|
||||
import (
|
||||
"context"
|
||||
)
|
||||
|
||||
// ----------------------
|
||||
// Search Module Builders
|
||||
// ----------------------
|
||||
|
||||
// SearchBuilder provides a fluent API for FT.SEARCH
|
||||
// (see original FTSearchOptions for all options).
|
||||
// EXPERIMENTAL: this API is subject to change, use with caution.
|
||||
type SearchBuilder struct {
|
||||
c *Client
|
||||
ctx context.Context
|
||||
index string
|
||||
query string
|
||||
options *FTSearchOptions
|
||||
}
|
||||
|
||||
// NewSearchBuilder creates a new SearchBuilder for FT.SEARCH commands.
|
||||
// EXPERIMENTAL: this API is subject to change, use with caution.
|
||||
func (c *Client) NewSearchBuilder(ctx context.Context, index, query string) *SearchBuilder {
|
||||
b := &SearchBuilder{c: c, ctx: ctx, index: index, query: query, options: &FTSearchOptions{LimitOffset: -1}}
|
||||
return b
|
||||
}
|
||||
|
||||
// WithScores includes WITHSCORES.
|
||||
func (b *SearchBuilder) WithScores() *SearchBuilder {
|
||||
b.options.WithScores = true
|
||||
return b
|
||||
}
|
||||
|
||||
// NoContent includes NOCONTENT.
|
||||
func (b *SearchBuilder) NoContent() *SearchBuilder { b.options.NoContent = true; return b }
|
||||
|
||||
// Verbatim includes VERBATIM.
|
||||
func (b *SearchBuilder) Verbatim() *SearchBuilder { b.options.Verbatim = true; return b }
|
||||
|
||||
// NoStopWords includes NOSTOPWORDS.
|
||||
func (b *SearchBuilder) NoStopWords() *SearchBuilder { b.options.NoStopWords = true; return b }
|
||||
|
||||
// WithPayloads includes WITHPAYLOADS.
|
||||
func (b *SearchBuilder) WithPayloads() *SearchBuilder {
|
||||
b.options.WithPayloads = true
|
||||
return b
|
||||
}
|
||||
|
||||
// WithSortKeys includes WITHSORTKEYS.
|
||||
func (b *SearchBuilder) WithSortKeys() *SearchBuilder {
|
||||
b.options.WithSortKeys = true
|
||||
return b
|
||||
}
|
||||
|
||||
// Filter adds a FILTER clause: FILTER <field> <min> <max>.
|
||||
func (b *SearchBuilder) Filter(field string, min, max interface{}) *SearchBuilder {
|
||||
b.options.Filters = append(b.options.Filters, FTSearchFilter{
|
||||
FieldName: field,
|
||||
Min: min,
|
||||
Max: max,
|
||||
})
|
||||
return b
|
||||
}
|
||||
|
||||
// GeoFilter adds a GEOFILTER clause: GEOFILTER <field> <lon> <lat> <radius> <unit>.
|
||||
func (b *SearchBuilder) GeoFilter(field string, lon, lat, radius float64, unit string) *SearchBuilder {
|
||||
b.options.GeoFilter = append(b.options.GeoFilter, FTSearchGeoFilter{
|
||||
FieldName: field,
|
||||
Longitude: lon,
|
||||
Latitude: lat,
|
||||
Radius: radius,
|
||||
Unit: unit,
|
||||
})
|
||||
return b
|
||||
}
|
||||
|
||||
// InKeys restricts the search to the given keys.
|
||||
func (b *SearchBuilder) InKeys(keys ...interface{}) *SearchBuilder {
|
||||
b.options.InKeys = append(b.options.InKeys, keys...)
|
||||
return b
|
||||
}
|
||||
|
||||
// InFields restricts the search to the given fields.
|
||||
func (b *SearchBuilder) InFields(fields ...interface{}) *SearchBuilder {
|
||||
b.options.InFields = append(b.options.InFields, fields...)
|
||||
return b
|
||||
}
|
||||
|
||||
// ReturnFields adds simple RETURN <n> <field>...
|
||||
func (b *SearchBuilder) ReturnFields(fields ...string) *SearchBuilder {
|
||||
for _, f := range fields {
|
||||
b.options.Return = append(b.options.Return, FTSearchReturn{FieldName: f})
|
||||
}
|
||||
return b
|
||||
}
|
||||
|
||||
// ReturnAs adds RETURN <field> AS <alias>.
|
||||
func (b *SearchBuilder) ReturnAs(field, alias string) *SearchBuilder {
|
||||
b.options.Return = append(b.options.Return, FTSearchReturn{FieldName: field, As: alias})
|
||||
return b
|
||||
}
|
||||
|
||||
// Slop adds SLOP <n>.
|
||||
func (b *SearchBuilder) Slop(slop int) *SearchBuilder {
|
||||
b.options.Slop = slop
|
||||
return b
|
||||
}
|
||||
|
||||
// Timeout adds TIMEOUT <ms>.
|
||||
func (b *SearchBuilder) Timeout(timeout int) *SearchBuilder {
|
||||
b.options.Timeout = timeout
|
||||
return b
|
||||
}
|
||||
|
||||
// InOrder includes INORDER.
|
||||
func (b *SearchBuilder) InOrder() *SearchBuilder {
|
||||
b.options.InOrder = true
|
||||
return b
|
||||
}
|
||||
|
||||
// Language sets LANGUAGE <lang>.
|
||||
func (b *SearchBuilder) Language(lang string) *SearchBuilder {
|
||||
b.options.Language = lang
|
||||
return b
|
||||
}
|
||||
|
||||
// Expander sets EXPANDER <expander>.
|
||||
func (b *SearchBuilder) Expander(expander string) *SearchBuilder {
|
||||
b.options.Expander = expander
|
||||
return b
|
||||
}
|
||||
|
||||
// Scorer sets SCORER <scorer>.
|
||||
func (b *SearchBuilder) Scorer(scorer string) *SearchBuilder {
|
||||
b.options.Scorer = scorer
|
||||
return b
|
||||
}
|
||||
|
||||
// ExplainScore includes EXPLAINSCORE.
|
||||
func (b *SearchBuilder) ExplainScore() *SearchBuilder {
|
||||
b.options.ExplainScore = true
|
||||
return b
|
||||
}
|
||||
|
||||
// Payload sets PAYLOAD <payload>.
|
||||
func (b *SearchBuilder) Payload(payload string) *SearchBuilder {
|
||||
b.options.Payload = payload
|
||||
return b
|
||||
}
|
||||
|
||||
// SortBy adds SORTBY <field> ASC|DESC.
|
||||
func (b *SearchBuilder) SortBy(field string, asc bool) *SearchBuilder {
|
||||
b.options.SortBy = append(b.options.SortBy, FTSearchSortBy{
|
||||
FieldName: field,
|
||||
Asc: asc,
|
||||
Desc: !asc,
|
||||
})
|
||||
return b
|
||||
}
|
||||
|
||||
// WithSortByCount includes WITHCOUNT (when used with SortBy).
|
||||
func (b *SearchBuilder) WithSortByCount() *SearchBuilder {
|
||||
b.options.SortByWithCount = true
|
||||
return b
|
||||
}
|
||||
|
||||
// Param adds a single PARAMS <k> <v>.
|
||||
func (b *SearchBuilder) Param(key string, value interface{}) *SearchBuilder {
|
||||
if b.options.Params == nil {
|
||||
b.options.Params = make(map[string]interface{}, 1)
|
||||
}
|
||||
b.options.Params[key] = value
|
||||
return b
|
||||
}
|
||||
|
||||
// ParamsMap adds multiple PARAMS at once.
|
||||
func (b *SearchBuilder) ParamsMap(p map[string]interface{}) *SearchBuilder {
|
||||
if b.options.Params == nil {
|
||||
b.options.Params = make(map[string]interface{}, len(p))
|
||||
}
|
||||
for k, v := range p {
|
||||
b.options.Params[k] = v
|
||||
}
|
||||
return b
|
||||
}
|
||||
|
||||
// Dialect sets DIALECT <version>.
|
||||
func (b *SearchBuilder) Dialect(version int) *SearchBuilder {
|
||||
b.options.DialectVersion = version
|
||||
return b
|
||||
}
|
||||
|
||||
// Limit sets OFFSET and COUNT. CountOnly uses LIMIT 0 0.
|
||||
func (b *SearchBuilder) Limit(offset, count int) *SearchBuilder {
|
||||
b.options.LimitOffset = offset
|
||||
b.options.Limit = count
|
||||
return b
|
||||
}
|
||||
func (b *SearchBuilder) CountOnly() *SearchBuilder { b.options.CountOnly = true; return b }
|
||||
|
||||
// Run executes FT.SEARCH and returns a typed result.
|
||||
func (b *SearchBuilder) Run() (FTSearchResult, error) {
|
||||
cmd := b.c.FTSearchWithArgs(b.ctx, b.index, b.query, b.options)
|
||||
return cmd.Result()
|
||||
}
|
||||
|
||||
// ----------------------
|
||||
// AggregateBuilder for FT.AGGREGATE
|
||||
// ----------------------
|
||||
|
||||
type AggregateBuilder struct {
|
||||
c *Client
|
||||
ctx context.Context
|
||||
index string
|
||||
query string
|
||||
options *FTAggregateOptions
|
||||
}
|
||||
|
||||
// NewAggregateBuilder creates a new AggregateBuilder for FT.AGGREGATE commands.
|
||||
// EXPERIMENTAL: this API is subject to change, use with caution.
|
||||
func (c *Client) NewAggregateBuilder(ctx context.Context, index, query string) *AggregateBuilder {
|
||||
return &AggregateBuilder{c: c, ctx: ctx, index: index, query: query, options: &FTAggregateOptions{LimitOffset: -1}}
|
||||
}
|
||||
|
||||
// Verbatim includes VERBATIM.
|
||||
func (b *AggregateBuilder) Verbatim() *AggregateBuilder { b.options.Verbatim = true; return b }
|
||||
|
||||
// AddScores includes ADDSCORES.
|
||||
func (b *AggregateBuilder) AddScores() *AggregateBuilder { b.options.AddScores = true; return b }
|
||||
|
||||
// Scorer sets SCORER <scorer>.
|
||||
func (b *AggregateBuilder) Scorer(s string) *AggregateBuilder {
|
||||
b.options.Scorer = s
|
||||
return b
|
||||
}
|
||||
|
||||
// LoadAll includes LOAD * (mutually exclusive with Load).
|
||||
func (b *AggregateBuilder) LoadAll() *AggregateBuilder {
|
||||
b.options.LoadAll = true
|
||||
return b
|
||||
}
|
||||
|
||||
// Load adds LOAD <n> <field> [AS alias]...
|
||||
// You can call it multiple times for multiple fields.
|
||||
func (b *AggregateBuilder) Load(field string, alias ...string) *AggregateBuilder {
|
||||
// each Load entry becomes one element in options.Load
|
||||
l := FTAggregateLoad{Field: field}
|
||||
if len(alias) > 0 {
|
||||
l.As = alias[0]
|
||||
}
|
||||
b.options.Load = append(b.options.Load, l)
|
||||
return b
|
||||
}
|
||||
|
||||
// Timeout sets TIMEOUT <ms>.
|
||||
func (b *AggregateBuilder) Timeout(ms int) *AggregateBuilder {
|
||||
b.options.Timeout = ms
|
||||
return b
|
||||
}
|
||||
|
||||
// Apply adds APPLY <field> [AS alias].
|
||||
func (b *AggregateBuilder) Apply(field string, alias ...string) *AggregateBuilder {
|
||||
a := FTAggregateApply{Field: field}
|
||||
if len(alias) > 0 {
|
||||
a.As = alias[0]
|
||||
}
|
||||
b.options.Apply = append(b.options.Apply, a)
|
||||
return b
|
||||
}
|
||||
|
||||
// GroupBy starts a new GROUPBY <fields...> clause.
|
||||
func (b *AggregateBuilder) GroupBy(fields ...interface{}) *AggregateBuilder {
|
||||
b.options.GroupBy = append(b.options.GroupBy, FTAggregateGroupBy{
|
||||
Fields: fields,
|
||||
})
|
||||
return b
|
||||
}
|
||||
|
||||
// Reduce adds a REDUCE <fn> [<#args> <args...>] clause to the *last* GROUPBY.
|
||||
func (b *AggregateBuilder) Reduce(fn SearchAggregator, args ...interface{}) *AggregateBuilder {
|
||||
if len(b.options.GroupBy) == 0 {
|
||||
// no GROUPBY yet — nothing to attach to
|
||||
return b
|
||||
}
|
||||
idx := len(b.options.GroupBy) - 1
|
||||
b.options.GroupBy[idx].Reduce = append(b.options.GroupBy[idx].Reduce, FTAggregateReducer{
|
||||
Reducer: fn,
|
||||
Args: args,
|
||||
})
|
||||
return b
|
||||
}
|
||||
|
||||
// ReduceAs does the same but also sets an alias: REDUCE <fn> … AS <alias>
|
||||
func (b *AggregateBuilder) ReduceAs(fn SearchAggregator, alias string, args ...interface{}) *AggregateBuilder {
|
||||
if len(b.options.GroupBy) == 0 {
|
||||
return b
|
||||
}
|
||||
idx := len(b.options.GroupBy) - 1
|
||||
b.options.GroupBy[idx].Reduce = append(b.options.GroupBy[idx].Reduce, FTAggregateReducer{
|
||||
Reducer: fn,
|
||||
Args: args,
|
||||
As: alias,
|
||||
})
|
||||
return b
|
||||
}
|
||||
|
||||
// SortBy adds SORTBY <field> ASC|DESC.
|
||||
func (b *AggregateBuilder) SortBy(field string, asc bool) *AggregateBuilder {
|
||||
sb := FTAggregateSortBy{FieldName: field, Asc: asc, Desc: !asc}
|
||||
b.options.SortBy = append(b.options.SortBy, sb)
|
||||
return b
|
||||
}
|
||||
|
||||
// SortByMax sets MAX <n> (only if SortBy was called).
|
||||
func (b *AggregateBuilder) SortByMax(max int) *AggregateBuilder {
|
||||
b.options.SortByMax = max
|
||||
return b
|
||||
}
|
||||
|
||||
// Filter sets FILTER <expr>.
|
||||
func (b *AggregateBuilder) Filter(expr string) *AggregateBuilder {
|
||||
b.options.Filter = expr
|
||||
return b
|
||||
}
|
||||
|
||||
// WithCursor enables WITHCURSOR [COUNT <n>] [MAXIDLE <ms>].
|
||||
func (b *AggregateBuilder) WithCursor(count, maxIdle int) *AggregateBuilder {
|
||||
b.options.WithCursor = true
|
||||
if b.options.WithCursorOptions == nil {
|
||||
b.options.WithCursorOptions = &FTAggregateWithCursor{}
|
||||
}
|
||||
b.options.WithCursorOptions.Count = count
|
||||
b.options.WithCursorOptions.MaxIdle = maxIdle
|
||||
return b
|
||||
}
|
||||
|
||||
// Params adds PARAMS <k v> pairs.
|
||||
func (b *AggregateBuilder) Params(p map[string]interface{}) *AggregateBuilder {
|
||||
if b.options.Params == nil {
|
||||
b.options.Params = make(map[string]interface{}, len(p))
|
||||
}
|
||||
for k, v := range p {
|
||||
b.options.Params[k] = v
|
||||
}
|
||||
return b
|
||||
}
|
||||
|
||||
// Dialect sets DIALECT <version>.
|
||||
func (b *AggregateBuilder) Dialect(version int) *AggregateBuilder {
|
||||
b.options.DialectVersion = version
|
||||
return b
|
||||
}
|
||||
|
||||
// Run executes FT.AGGREGATE and returns a typed result.
|
||||
func (b *AggregateBuilder) Run() (*FTAggregateResult, error) {
|
||||
cmd := b.c.FTAggregateWithArgs(b.ctx, b.index, b.query, b.options)
|
||||
return cmd.Result()
|
||||
}
|
||||
|
||||
// ----------------------
|
||||
// CreateIndexBuilder for FT.CREATE
|
||||
// ----------------------
|
||||
// CreateIndexBuilder is builder for FT.CREATE
|
||||
// EXPERIMENTAL: this API is subject to change, use with caution.
|
||||
type CreateIndexBuilder struct {
|
||||
c *Client
|
||||
ctx context.Context
|
||||
index string
|
||||
options *FTCreateOptions
|
||||
schema []*FieldSchema
|
||||
}
|
||||
|
||||
// NewCreateIndexBuilder creates a new CreateIndexBuilder for FT.CREATE commands.
|
||||
// EXPERIMENTAL: this API is subject to change, use with caution.
|
||||
func (c *Client) NewCreateIndexBuilder(ctx context.Context, index string) *CreateIndexBuilder {
|
||||
return &CreateIndexBuilder{c: c, ctx: ctx, index: index, options: &FTCreateOptions{}}
|
||||
}
|
||||
|
||||
// OnHash sets ON HASH.
|
||||
func (b *CreateIndexBuilder) OnHash() *CreateIndexBuilder { b.options.OnHash = true; return b }
|
||||
|
||||
// OnJSON sets ON JSON.
|
||||
func (b *CreateIndexBuilder) OnJSON() *CreateIndexBuilder { b.options.OnJSON = true; return b }
|
||||
|
||||
// Prefix sets PREFIX.
|
||||
func (b *CreateIndexBuilder) Prefix(prefixes ...interface{}) *CreateIndexBuilder {
|
||||
b.options.Prefix = prefixes
|
||||
return b
|
||||
}
|
||||
|
||||
// Filter sets FILTER.
|
||||
func (b *CreateIndexBuilder) Filter(filter string) *CreateIndexBuilder {
|
||||
b.options.Filter = filter
|
||||
return b
|
||||
}
|
||||
|
||||
// DefaultLanguage sets LANGUAGE.
|
||||
func (b *CreateIndexBuilder) DefaultLanguage(lang string) *CreateIndexBuilder {
|
||||
b.options.DefaultLanguage = lang
|
||||
return b
|
||||
}
|
||||
|
||||
// LanguageField sets LANGUAGE_FIELD.
|
||||
func (b *CreateIndexBuilder) LanguageField(field string) *CreateIndexBuilder {
|
||||
b.options.LanguageField = field
|
||||
return b
|
||||
}
|
||||
|
||||
// Score sets SCORE.
|
||||
func (b *CreateIndexBuilder) Score(score float64) *CreateIndexBuilder {
|
||||
b.options.Score = score
|
||||
return b
|
||||
}
|
||||
|
||||
// ScoreField sets SCORE_FIELD.
|
||||
func (b *CreateIndexBuilder) ScoreField(field string) *CreateIndexBuilder {
|
||||
b.options.ScoreField = field
|
||||
return b
|
||||
}
|
||||
|
||||
// PayloadField sets PAYLOAD_FIELD.
|
||||
func (b *CreateIndexBuilder) PayloadField(field string) *CreateIndexBuilder {
|
||||
b.options.PayloadField = field
|
||||
return b
|
||||
}
|
||||
|
||||
// NoOffsets includes NOOFFSETS.
|
||||
func (b *CreateIndexBuilder) NoOffsets() *CreateIndexBuilder { b.options.NoOffsets = true; return b }
|
||||
|
||||
// Temporary sets TEMPORARY seconds.
|
||||
func (b *CreateIndexBuilder) Temporary(sec int) *CreateIndexBuilder {
|
||||
b.options.Temporary = sec
|
||||
return b
|
||||
}
|
||||
|
||||
// NoHL includes NOHL.
|
||||
func (b *CreateIndexBuilder) NoHL() *CreateIndexBuilder { b.options.NoHL = true; return b }
|
||||
|
||||
// NoFields includes NOFIELDS.
|
||||
func (b *CreateIndexBuilder) NoFields() *CreateIndexBuilder { b.options.NoFields = true; return b }
|
||||
|
||||
// NoFreqs includes NOFREQS.
|
||||
func (b *CreateIndexBuilder) NoFreqs() *CreateIndexBuilder { b.options.NoFreqs = true; return b }
|
||||
|
||||
// StopWords sets STOPWORDS.
|
||||
func (b *CreateIndexBuilder) StopWords(words ...interface{}) *CreateIndexBuilder {
|
||||
b.options.StopWords = words
|
||||
return b
|
||||
}
|
||||
|
||||
// SkipInitialScan includes SKIPINITIALSCAN.
|
||||
func (b *CreateIndexBuilder) SkipInitialScan() *CreateIndexBuilder {
|
||||
b.options.SkipInitialScan = true
|
||||
return b
|
||||
}
|
||||
|
||||
// Schema adds a FieldSchema.
|
||||
func (b *CreateIndexBuilder) Schema(field *FieldSchema) *CreateIndexBuilder {
|
||||
b.schema = append(b.schema, field)
|
||||
return b
|
||||
}
|
||||
|
||||
// Run executes FT.CREATE and returns the status.
|
||||
func (b *CreateIndexBuilder) Run() (string, error) {
|
||||
cmd := b.c.FTCreate(b.ctx, b.index, b.options, b.schema...)
|
||||
return cmd.Result()
|
||||
}
|
||||
|
||||
// ----------------------
|
||||
// DropIndexBuilder for FT.DROPINDEX
|
||||
// ----------------------
|
||||
// DropIndexBuilder is a builder for FT.DROPINDEX
|
||||
// EXPERIMENTAL: this API is subject to change, use with caution.
|
||||
type DropIndexBuilder struct {
|
||||
c *Client
|
||||
ctx context.Context
|
||||
index string
|
||||
options *FTDropIndexOptions
|
||||
}
|
||||
|
||||
// NewDropIndexBuilder creates a new DropIndexBuilder for FT.DROPINDEX commands.
|
||||
// EXPERIMENTAL: this API is subject to change, use with caution.
|
||||
func (c *Client) NewDropIndexBuilder(ctx context.Context, index string) *DropIndexBuilder {
|
||||
return &DropIndexBuilder{c: c, ctx: ctx, index: index}
|
||||
}
|
||||
|
||||
// DeleteRuncs includes DD.
|
||||
func (b *DropIndexBuilder) DeleteDocs() *DropIndexBuilder { b.options.DeleteDocs = true; return b }
|
||||
|
||||
// Run executes FT.DROPINDEX.
|
||||
func (b *DropIndexBuilder) Run() (string, error) {
|
||||
cmd := b.c.FTDropIndexWithArgs(b.ctx, b.index, b.options)
|
||||
return cmd.Result()
|
||||
}
|
||||
|
||||
// ----------------------
|
||||
// AliasBuilder for FT.ALIAS* commands
|
||||
// ----------------------
|
||||
// AliasBuilder is builder for FT.ALIAS* commands
|
||||
// EXPERIMENTAL: this API is subject to change, use with caution.
|
||||
type AliasBuilder struct {
|
||||
c *Client
|
||||
ctx context.Context
|
||||
alias string
|
||||
index string
|
||||
action string // add|del|update
|
||||
}
|
||||
|
||||
// NewAliasBuilder creates a new AliasBuilder for FT.ALIAS* commands.
|
||||
// EXPERIMENTAL: this API is subject to change, use with caution.
|
||||
func (c *Client) NewAliasBuilder(ctx context.Context, alias string) *AliasBuilder {
|
||||
return &AliasBuilder{c: c, ctx: ctx, alias: alias}
|
||||
}
|
||||
|
||||
// Action sets the action for the alias builder.
|
||||
func (b *AliasBuilder) Action(action string) *AliasBuilder {
|
||||
b.action = action
|
||||
return b
|
||||
}
|
||||
|
||||
// Add sets the action to "add" and requires an index.
|
||||
func (b *AliasBuilder) Add(index string) *AliasBuilder {
|
||||
b.action = "add"
|
||||
b.index = index
|
||||
return b
|
||||
}
|
||||
|
||||
// Del sets the action to "del".
|
||||
func (b *AliasBuilder) Del() *AliasBuilder {
|
||||
b.action = "del"
|
||||
return b
|
||||
}
|
||||
|
||||
// Update sets the action to "update" and requires an index.
|
||||
func (b *AliasBuilder) Update(index string) *AliasBuilder {
|
||||
b.action = "update"
|
||||
b.index = index
|
||||
return b
|
||||
}
|
||||
|
||||
// Run executes the configured alias command.
|
||||
func (b *AliasBuilder) Run() (string, error) {
|
||||
switch b.action {
|
||||
case "add":
|
||||
cmd := b.c.FTAliasAdd(b.ctx, b.index, b.alias)
|
||||
return cmd.Result()
|
||||
case "del":
|
||||
cmd := b.c.FTAliasDel(b.ctx, b.alias)
|
||||
return cmd.Result()
|
||||
case "update":
|
||||
cmd := b.c.FTAliasUpdate(b.ctx, b.index, b.alias)
|
||||
return cmd.Result()
|
||||
}
|
||||
return "", nil
|
||||
}
|
||||
|
||||
// ----------------------
|
||||
// ExplainBuilder for FT.EXPLAIN
|
||||
// ----------------------
|
||||
// ExplainBuilder is builder for FT.EXPLAIN
|
||||
// EXPERIMENTAL: this API is subject to change, use with caution.
|
||||
type ExplainBuilder struct {
|
||||
c *Client
|
||||
ctx context.Context
|
||||
index string
|
||||
query string
|
||||
options *FTExplainOptions
|
||||
}
|
||||
|
||||
// NewExplainBuilder creates a new ExplainBuilder for FT.EXPLAIN commands.
|
||||
// EXPERIMENTAL: this API is subject to change, use with caution.
|
||||
func (c *Client) NewExplainBuilder(ctx context.Context, index, query string) *ExplainBuilder {
|
||||
return &ExplainBuilder{c: c, ctx: ctx, index: index, query: query, options: &FTExplainOptions{}}
|
||||
}
|
||||
|
||||
// Dialect sets dialect for EXPLAINCLI.
|
||||
func (b *ExplainBuilder) Dialect(d string) *ExplainBuilder { b.options.Dialect = d; return b }
|
||||
|
||||
// Run executes FT.EXPLAIN and returns the plan.
|
||||
func (b *ExplainBuilder) Run() (string, error) {
|
||||
cmd := b.c.FTExplainWithArgs(b.ctx, b.index, b.query, b.options)
|
||||
return cmd.Result()
|
||||
}
|
||||
|
||||
// ----------------------
|
||||
// InfoBuilder for FT.INFO
|
||||
// ----------------------
|
||||
|
||||
type FTInfoBuilder struct {
|
||||
c *Client
|
||||
ctx context.Context
|
||||
index string
|
||||
}
|
||||
|
||||
// NewSearchInfoBuilder creates a new FTInfoBuilder for FT.INFO commands.
|
||||
func (c *Client) NewSearchInfoBuilder(ctx context.Context, index string) *FTInfoBuilder {
|
||||
return &FTInfoBuilder{c: c, ctx: ctx, index: index}
|
||||
}
|
||||
|
||||
// Run executes FT.INFO and returns detailed info.
|
||||
func (b *FTInfoBuilder) Run() (FTInfoResult, error) {
|
||||
cmd := b.c.FTInfo(b.ctx, b.index)
|
||||
return cmd.Result()
|
||||
}
|
||||
|
||||
// ----------------------
|
||||
// SpellCheckBuilder for FT.SPELLCHECK
|
||||
// ----------------------
|
||||
// SpellCheckBuilder is builder for FT.SPELLCHECK
|
||||
// EXPERIMENTAL: this API is subject to change, use with caution.
|
||||
type SpellCheckBuilder struct {
|
||||
c *Client
|
||||
ctx context.Context
|
||||
index string
|
||||
query string
|
||||
options *FTSpellCheckOptions
|
||||
}
|
||||
|
||||
// NewSpellCheckBuilder creates a new SpellCheckBuilder for FT.SPELLCHECK commands.
|
||||
// EXPERIMENTAL: this API is subject to change, use with caution.
|
||||
func (c *Client) NewSpellCheckBuilder(ctx context.Context, index, query string) *SpellCheckBuilder {
|
||||
return &SpellCheckBuilder{c: c, ctx: ctx, index: index, query: query, options: &FTSpellCheckOptions{}}
|
||||
}
|
||||
|
||||
// Distance sets MAXDISTANCE.
|
||||
func (b *SpellCheckBuilder) Distance(d int) *SpellCheckBuilder { b.options.Distance = d; return b }
|
||||
|
||||
// Terms sets INCLUDE or EXCLUDE terms.
|
||||
func (b *SpellCheckBuilder) Terms(include bool, dictionary string, terms ...interface{}) *SpellCheckBuilder {
|
||||
if b.options.Terms == nil {
|
||||
b.options.Terms = &FTSpellCheckTerms{}
|
||||
}
|
||||
if include {
|
||||
b.options.Terms.Inclusion = "INCLUDE"
|
||||
} else {
|
||||
b.options.Terms.Inclusion = "EXCLUDE"
|
||||
}
|
||||
b.options.Terms.Dictionary = dictionary
|
||||
b.options.Terms.Terms = terms
|
||||
return b
|
||||
}
|
||||
|
||||
// Dialect sets dialect version.
|
||||
func (b *SpellCheckBuilder) Dialect(d int) *SpellCheckBuilder { b.options.Dialect = d; return b }
|
||||
|
||||
// Run executes FT.SPELLCHECK and returns suggestions.
|
||||
func (b *SpellCheckBuilder) Run() ([]SpellCheckResult, error) {
|
||||
cmd := b.c.FTSpellCheckWithArgs(b.ctx, b.index, b.query, b.options)
|
||||
return cmd.Result()
|
||||
}
|
||||
|
||||
// ----------------------
|
||||
// DictBuilder for FT.DICT* commands
|
||||
// ----------------------
|
||||
// DictBuilder is builder for FT.DICT* commands
|
||||
// EXPERIMENTAL: this API is subject to change, use with caution.
|
||||
type DictBuilder struct {
|
||||
c *Client
|
||||
ctx context.Context
|
||||
dict string
|
||||
terms []interface{}
|
||||
action string // add|del|dump
|
||||
}
|
||||
|
||||
// NewDictBuilder creates a new DictBuilder for FT.DICT* commands.
|
||||
// EXPERIMENTAL: this API is subject to change, use with caution.
|
||||
func (c *Client) NewDictBuilder(ctx context.Context, dict string) *DictBuilder {
|
||||
return &DictBuilder{c: c, ctx: ctx, dict: dict}
|
||||
}
|
||||
|
||||
// Action sets the action for the dictionary builder.
|
||||
func (b *DictBuilder) Action(action string) *DictBuilder {
|
||||
b.action = action
|
||||
return b
|
||||
}
|
||||
|
||||
// Add sets the action to "add" and requires terms.
|
||||
func (b *DictBuilder) Add(terms ...interface{}) *DictBuilder {
|
||||
b.action = "add"
|
||||
b.terms = terms
|
||||
return b
|
||||
}
|
||||
|
||||
// Del sets the action to "del" and requires terms.
|
||||
func (b *DictBuilder) Del(terms ...interface{}) *DictBuilder {
|
||||
b.action = "del"
|
||||
b.terms = terms
|
||||
return b
|
||||
}
|
||||
|
||||
// Dump sets the action to "dump".
|
||||
func (b *DictBuilder) Dump() *DictBuilder {
|
||||
b.action = "dump"
|
||||
return b
|
||||
}
|
||||
|
||||
// Run executes the configured dictionary command.
|
||||
func (b *DictBuilder) Run() (interface{}, error) {
|
||||
switch b.action {
|
||||
case "add":
|
||||
cmd := b.c.FTDictAdd(b.ctx, b.dict, b.terms...)
|
||||
return cmd.Result()
|
||||
case "del":
|
||||
cmd := b.c.FTDictDel(b.ctx, b.dict, b.terms...)
|
||||
return cmd.Result()
|
||||
case "dump":
|
||||
cmd := b.c.FTDictDump(b.ctx, b.dict)
|
||||
return cmd.Result()
|
||||
}
|
||||
return nil, nil
|
||||
}
|
||||
|
||||
// ----------------------
|
||||
// TagValsBuilder for FT.TAGVALS
|
||||
// ----------------------
|
||||
// TagValsBuilder is builder for FT.TAGVALS
|
||||
// EXPERIMENTAL: this API is subject to change, use with caution.
|
||||
type TagValsBuilder struct {
|
||||
c *Client
|
||||
ctx context.Context
|
||||
index string
|
||||
field string
|
||||
}
|
||||
|
||||
// NewTagValsBuilder creates a new TagValsBuilder for FT.TAGVALS commands.
|
||||
// EXPERIMENTAL: this API is subject to change, use with caution.
|
||||
func (c *Client) NewTagValsBuilder(ctx context.Context, index, field string) *TagValsBuilder {
|
||||
return &TagValsBuilder{c: c, ctx: ctx, index: index, field: field}
|
||||
}
|
||||
|
||||
// Run executes FT.TAGVALS and returns tag values.
|
||||
func (b *TagValsBuilder) Run() ([]string, error) {
|
||||
cmd := b.c.FTTagVals(b.ctx, b.index, b.field)
|
||||
return cmd.Result()
|
||||
}
|
||||
|
||||
// ----------------------
|
||||
// CursorBuilder for FT.CURSOR*
|
||||
// ----------------------
|
||||
// CursorBuilder is builder for FT.CURSOR* commands
|
||||
// EXPERIMENTAL: this API is subject to change, use with caution.
|
||||
type CursorBuilder struct {
|
||||
c *Client
|
||||
ctx context.Context
|
||||
index string
|
||||
cursorId int64
|
||||
count int
|
||||
action string // read|del
|
||||
}
|
||||
|
||||
// NewCursorBuilder creates a new CursorBuilder for FT.CURSOR* commands.
|
||||
// EXPERIMENTAL: this API is subject to change, use with caution.
|
||||
func (c *Client) NewCursorBuilder(ctx context.Context, index string, cursorId int64) *CursorBuilder {
|
||||
return &CursorBuilder{c: c, ctx: ctx, index: index, cursorId: cursorId}
|
||||
}
|
||||
|
||||
// Action sets the action for the cursor builder.
|
||||
func (b *CursorBuilder) Action(action string) *CursorBuilder {
|
||||
b.action = action
|
||||
return b
|
||||
}
|
||||
|
||||
// Read sets the action to "read".
|
||||
func (b *CursorBuilder) Read() *CursorBuilder {
|
||||
b.action = "read"
|
||||
return b
|
||||
}
|
||||
|
||||
// Del sets the action to "del".
|
||||
func (b *CursorBuilder) Del() *CursorBuilder {
|
||||
b.action = "del"
|
||||
return b
|
||||
}
|
||||
|
||||
// Count for READ.
|
||||
func (b *CursorBuilder) Count(count int) *CursorBuilder { b.count = count; return b }
|
||||
|
||||
// Run executes the cursor command.
|
||||
func (b *CursorBuilder) Run() (interface{}, error) {
|
||||
switch b.action {
|
||||
case "read":
|
||||
cmd := b.c.FTCursorRead(b.ctx, b.index, int(b.cursorId), b.count)
|
||||
return cmd.Result()
|
||||
case "del":
|
||||
cmd := b.c.FTCursorDel(b.ctx, b.index, int(b.cursorId))
|
||||
return cmd.Result()
|
||||
}
|
||||
return nil, nil
|
||||
}
|
||||
|
||||
// ----------------------
|
||||
// SynUpdateBuilder for FT.SYNUPDATE
|
||||
// ----------------------
|
||||
// SyncUpdateBuilder is builder for FT.SYNCUPDATE
|
||||
// EXPERIMENTAL: this API is subject to change, use with caution.
|
||||
type SynUpdateBuilder struct {
|
||||
c *Client
|
||||
ctx context.Context
|
||||
index string
|
||||
groupId interface{}
|
||||
options *FTSynUpdateOptions
|
||||
terms []interface{}
|
||||
}
|
||||
|
||||
// NewSynUpdateBuilder creates a new SynUpdateBuilder for FT.SYNUPDATE commands.
|
||||
// EXPERIMENTAL: this API is subject to change, use with caution.
|
||||
func (c *Client) NewSynUpdateBuilder(ctx context.Context, index string, groupId interface{}) *SynUpdateBuilder {
|
||||
return &SynUpdateBuilder{c: c, ctx: ctx, index: index, groupId: groupId, options: &FTSynUpdateOptions{}}
|
||||
}
|
||||
|
||||
// SkipInitialScan includes SKIPINITIALSCAN.
|
||||
func (b *SynUpdateBuilder) SkipInitialScan() *SynUpdateBuilder {
|
||||
b.options.SkipInitialScan = true
|
||||
return b
|
||||
}
|
||||
|
||||
// Terms adds synonyms to the group.
|
||||
func (b *SynUpdateBuilder) Terms(terms ...interface{}) *SynUpdateBuilder { b.terms = terms; return b }
|
||||
|
||||
// Run executes FT.SYNUPDATE.
|
||||
func (b *SynUpdateBuilder) Run() (string, error) {
|
||||
cmd := b.c.FTSynUpdateWithArgs(b.ctx, b.index, b.groupId, b.options, b.terms)
|
||||
return cmd.Result()
|
||||
}
|
||||
Reference in New Issue
Block a user