io.lettuce.core.api.async

Interface RediSearchAsyncCommands<K,V>

Type Parameters:

K - Key type.

V - Value type.

All Known Subinterfaces:

RedisAdvancedClusterAsyncCommands<K,V>, RedisAsyncCommands<K,V>, RedisClusterAsyncCommands<K,V>, RedisClusterPubSubAsyncCommands<K,V>, RedisPubSubAsyncCommands<K,V>

All Known Implementing Classes:

AbstractRedisAsyncCommands, RedisAdvancedClusterAsyncCommandsImpl, RedisAsyncCommandsImpl, RedisClusterPubSubAsyncCommandsImpl, RedisPubSubAsyncCommandsImpl

public interface RediSearchAsyncCommands<K,V>

Asynchronous executed commands for RediSearch functionality

Since:

6.8

Author:

Tihomir Mateev

See Also:

RediSearch

Generated class:

by io.lettuce.apigenerator.CreateAsyncApi

Method Summary

Modifier and Type	Method and Description
RedisFuture<AggregationReply<K,V>>	ftAggregate(K index, V query) Run a search query on an index and perform basic aggregate transformations using default options.
RedisFuture<AggregationReply<K,V>>	ftAggregate(K index, V query, AggregateArgs<K,V> args) Run a search query on an index and perform advanced aggregate transformations with a processing pipeline.
RedisFuture<String>	ftAliasadd(K alias, K index) Add an alias to a search index.
RedisFuture<String>	ftAliasdel(K alias) Remove an alias from a search index.
RedisFuture<String>	ftAliasupdate(K alias, K index) Update an existing alias to point to a different search index.
RedisFuture<String>	ftAlter(K index, boolean skipInitialScan, List<FieldArgs<K>> fieldArgs) Add new attributes to an existing search index.
RedisFuture<String>	ftAlter(K index, List<FieldArgs<K>> fieldArgs) Add new attributes to an existing search index.
RedisFuture<String>	ftCreate(K index, CreateArgs<K,V> arguments, List<FieldArgs<K>> fieldArgs) Create a new search index with the given name, custom configuration, and field definitions.
RedisFuture<String>	ftCreate(K index, List<FieldArgs<K>> fieldArgs) Create a new search index with the given name and field definitions using default settings.
RedisFuture<String>	ftCursordel(K index, long cursorId) Delete a cursor and free its associated resources.
RedisFuture<AggregationReply<K,V>>	ftCursorread(K index, long cursorId) Read next results from an existing cursor using the default batch size.
RedisFuture<AggregationReply<K,V>>	ftCursorread(K index, long cursorId, int count) Read next results from an existing cursor.
RedisFuture<Long>	ftDictadd(K dict, V... terms) Add terms to a dictionary.
RedisFuture<Long>	ftDictdel(K dict, V... terms) Delete terms from a dictionary.
RedisFuture<List<V>>	ftDictdump(K dict) Dump all terms in a dictionary.
RedisFuture<String>	ftDropindex(K index) Drop a search index without deleting the associated documents.
RedisFuture<String>	ftDropindex(K index, boolean deleteDocuments) Drop a search index with optional document deletion.
RedisFuture<String>	ftExplain(K index, V query) Return the execution plan for a complex query.
RedisFuture<String>	ftExplain(K index, V query, ExplainArgs<K,V> args) Return the execution plan for a complex query with additional options.
RedisFuture<List<V>>	ftList() Return a list of all existing indexes.
RedisFuture<SearchReply<K,V>>	ftSearch(K index, V query) Search the index with a textual query using default search options.
RedisFuture<SearchReply<K,V>>	ftSearch(K index, V query, SearchArgs<K,V> args) Search the index with a textual query using advanced search options and filters.
RedisFuture<SpellCheckResult<V>>	ftSpellcheck(K index, V query) Perform spelling correction on a query, returning suggestions for misspelled terms.
RedisFuture<SpellCheckResult<V>>	ftSpellcheck(K index, V query, SpellCheckArgs<K,V> args) Perform spelling correction on a query with additional options.
RedisFuture<Long>	ftSugadd(K key, V suggestion, double score) Add a suggestion string to an auto-complete suggestion dictionary.
RedisFuture<Long>	ftSugadd(K key, V suggestion, double score, SugAddArgs<K,V> args) Add a suggestion string to an auto-complete suggestion dictionary with additional options.
RedisFuture<Boolean>	ftSugdel(K key, V suggestion) Delete a string from a suggestion dictionary.
RedisFuture<List<Suggestion<V>>>	ftSugget(K key, V prefix) Get completion suggestions for a prefix.
RedisFuture<List<Suggestion<V>>>	ftSugget(K key, V prefix, SugGetArgs<K,V> args) Get completion suggestions for a prefix with additional options.
RedisFuture<Long>	ftSuglen(K key) Get the size of an auto-complete suggestion dictionary.
RedisFuture<Map<V,List<V>>>	ftSyndump(K index) Dump synonym group contents.
RedisFuture<String>	ftSynupdate(K index, V synonymGroupId, SynUpdateArgs<K,V> args, V... terms) Update a synonym group with additional terms and options.
RedisFuture<String>	ftSynupdate(K index, V synonymGroupId, V... terms) Update a synonym group with additional terms.
RedisFuture<List<V>>	ftTagvals(K index, K fieldName) Return a distinct set of values indexed in a Tag field.

Method Detail

ftCreate

@Experimental
RedisFuture<String> ftCreate(K index,
                                           List<FieldArgs<K>> fieldArgs)

Create a new search index with the given name and field definitions using default settings.

This command creates a new search index that enables full-text search, filtering, and aggregation capabilities on Redis data structures. The index will use default settings for data type (HASH), key prefixes (all keys), and other configuration options.

Time complexity: O(K) at creation where K is the number of fields, O(N) if scanning the keyspace is triggered, where N is the number of keys in the keyspace

Parameters:

index - the index name, as a key

fieldArgs - the FieldArgs list defining the searchable fields and their types

Returns:

"OK" if the index was created successfully

See Also:

FT.CREATE, CreateArgs, FieldArgs, ftCreate(Object, CreateArgs, List), ftDropindex(Object)

ftCreate

@Experimental
RedisFuture<String> ftCreate(K index,
                                           CreateArgs<K,V> arguments,
                                           List<FieldArgs<K>> fieldArgs)

Create a new search index with the given name, custom configuration, and field definitions.

This command creates a new search index with advanced configuration options that control how the index behaves, what data it indexes, and how it processes documents. This variant provides full control over index creation parameters.

The CreateArgs parameter allows you to specify:

• Data type: HASH (default) or JSON documents
• Key prefixes: Which keys to index based on prefix patterns
• Filters: Conditional indexing based on field values
• Language settings: Default language and language field for stemming
• Performance options: NOOFFSETS, NOHL, NOFIELDS, NOFREQS for memory optimization
• Temporary indexes: Auto-expiring indexes for short-term use

Time complexity: O(K) at creation where K is the number of fields, O(N) if scanning the keyspace is triggered, where N is the number of keys in the keyspace

Parameters:

index - the index name, as a key

arguments - the index CreateArgs containing configuration options

fieldArgs - the FieldArgs list defining the searchable fields and their types

Returns:

"OK" if the index was created successfully

Since:

6.8

See Also:

FT.CREATE, CreateArgs, FieldArgs, ftCreate(Object, List), ftDropindex(Object)

ftAliasadd

@Experimental
RedisFuture<String> ftAliasadd(K alias,
                                             K index)

Add an alias to a search index.

This command creates an alias that points to an existing search index, allowing applications to reference the index by an alternative name. Aliases provide a level of indirection that enables transparent index management and migration strategies.

Key features and use cases:

• Index abstraction: Applications can use stable alias names while underlying indexes change
• Blue-green deployments: Switch traffic between old and new indexes seamlessly
• A/B testing: Route different application instances to different indexes
• Maintenance windows: Redirect queries during index rebuilds or migrations

Important notes:

• An index can have multiple aliases, but an alias can only point to one index
• Aliases cannot reference other aliases (no alias chaining)
• If the alias already exists, this command will fail with an error
• Use ftAliasupdate(Object, Object) to reassign an existing alias

Time complexity: O(1)

Parameters:

alias - the alias name to create

index - the target index name that the alias will point to

Returns:

"OK" if the alias was successfully created

Since:

6.8

See Also:

FT.ALIASADD, ftAliasupdate(Object, Object), ftAliasdel(Object)

ftAliasupdate

@Experimental
RedisFuture<String> ftAliasupdate(K alias,
                                                K index)

Update an existing alias to point to a different search index.

This command updates an existing alias to point to a different index, or creates the alias if it doesn't exist. Unlike ftAliasadd(Object, Object), this command will succeed even if the alias already exists, making it useful for atomic alias updates during index migrations.

Key features and use cases:

• Atomic updates: Change alias target without downtime
• Index migration: Seamlessly switch from old to new index versions
• Rollback capability: Quickly revert to previous index if issues arise
• Blue-green deployments: Switch production traffic between index versions

Important notes:

• If the alias doesn't exist, it will be created (same as ftAliasadd)
• If the alias exists, it will be updated to point to the new index
• The previous index association is removed automatically
• This operation is atomic - no intermediate state where alias is undefined

Time complexity: O(1)

Parameters:

alias - the alias name to update or create

index - the target index name that the alias will point to

Returns:

"OK" if the alias was successfully updated

Since:

6.8

See Also:

FT.ALIASUPDATE, ftAliasadd(Object, Object), ftAliasdel(Object)

ftAliasdel

@Experimental
RedisFuture<String> ftAliasdel(K alias)

Remove an alias from a search index.

This command removes an existing alias, breaking the association between the alias name and its target index. The underlying index remains unchanged and accessible by its original name.

Key features and use cases:

• Cleanup: Remove unused or obsolete aliases
• Security: Revoke access to indexes through specific alias names
• Maintenance: Temporarily disable access during maintenance windows
• Resource management: Clean up aliases before index deletion

Important notes:

• Only the alias is removed - the target index is not affected
• If the alias doesn't exist, this command will fail with an error
• Applications using the alias will receive errors after deletion
• Consider using ftAliasupdate(Object, Object) to redirect before deletion

Time complexity: O(1)

Parameters:

alias - the alias name to remove

Returns:

"OK" if the alias was successfully removed

Since:

6.8

See Also:

FT.ALIASDEL, ftAliasadd(Object, Object), ftAliasupdate(Object, Object)

ftAlter

@Experimental
RedisFuture<String> ftAlter(K index,
                                          boolean skipInitialScan,
                                          List<FieldArgs<K>> fieldArgs)

Add new attributes to an existing search index.

This command allows you to extend an existing search index by adding new searchable fields without recreating the entire index. The new attributes will be applied to future document updates and can optionally be applied to existing documents through reindexing.

Key features and considerations:

• Non-destructive: Existing index structure and data remain intact
• Incremental indexing: New fields are indexed as documents are updated
• Reindexing control: Option to skip initial scan for performance
• Field limitations: Text field limits may apply based on index creation options

Important notes:

• If the index was created without MAXTEXTFIELDS, you may be limited to 32 total text attributes
• New attributes are only indexed for documents that are updated after the ALTER command
• Use SKIPINITIALSCAN to avoid scanning existing documents if immediate indexing is not required

Time complexity: O(N) where N is the number of keys in the keyspace if initial scan is performed, O(1) if SKIPINITIALSCAN is used

Parameters:

index - the index name, as a key

skipInitialScan - if true, skip scanning and indexing existing documents; if false, scan and index existing documents with the new attributes

fieldArgs - the FieldArgs list defining the new searchable fields and their types to add

Returns:

"OK" if the index was successfully altered

Since:

6.8

See Also:

FT.ALTER, FieldArgs, ftCreate(Object, List), ftCreate(Object, CreateArgs, List)

ftAlter

@Experimental
RedisFuture<String> ftAlter(K index,
                                          List<FieldArgs<K>> fieldArgs)

Add new attributes to an existing search index.

This command allows you to extend an existing search index by adding new searchable fields without recreating the entire index. The new attributes will be applied to future document updates and can optionally be applied to existing documents through reindexing.

Key features and considerations:

• Non-destructive: Existing index structure and data remain intact
• Incremental indexing: New fields are indexed as documents are updated
• Reindexing control: Option to skip initial scan for performance
• Field limitations: Text field limits may apply based on index creation options

Time complexity: O(N) where N is the number of keys in the keyspace if initial scan is performed

Parameters:

index - the index name, as a key

fieldArgs - the FieldArgs list defining the new searchable fields and their types to add

Returns:

"OK" if the index was successfully altered

Since:

6.8

See Also:

FT.ALTER, FieldArgs, ftCreate(Object, List), ftCreate(Object, CreateArgs, List)

ftTagvals

@Experimental
RedisFuture<List<V>> ftTagvals(K index,
                                             K fieldName)

Return a distinct set of values indexed in a Tag field.

This command retrieves all unique values that have been indexed in a specific Tag field within a search index. It's particularly useful for discovering the range of values available in categorical fields such as cities, categories, status values, or any other enumerated data.

Key features and use cases:

• Data exploration: Discover all possible values in a tag field
• Filter building: Populate dropdown lists or filter options in applications
• Data validation: Verify expected values are present in the index
• Analytics: Understand the distribution of categorical data

Important limitations:

• Only works with Tag fields defined in the index schema
• No paging or sorting is provided - all values are returned at once
• Tags are not alphabetically sorted in the response
• Returned strings are lowercase with whitespaces removed
• Performance scales with the number of unique values (O(N) complexity)

Example usage scenarios:

• Retrieving all available product categories for an e-commerce filter
• Getting all city names indexed for location-based searches
• Listing all status values (active, inactive, pending) for administrative interfaces
• Discovering all tags or labels applied to content

Time complexity: O(N) where N is the number of distinct values in the tag field

Parameters:

index - the index name containing the tag field

fieldName - the name of the Tag field defined in the index schema

Returns:

a list of all distinct values indexed in the specified tag field. The list contains the raw tag values as they were indexed (lowercase, whitespace removed).

Since:

6.8

See Also:

FT.TAGVALS, ftCreate(Object, List), ftCreate(Object, CreateArgs, List)

ftSpellcheck

@Experimental
RedisFuture<SpellCheckResult<V>> ftSpellcheck(K index,
                                                            V query)

Perform spelling correction on a query, returning suggestions for misspelled terms.

This command analyzes the query for misspelled terms and provides spelling suggestions based on the indexed terms and optionally custom dictionaries. A misspelled term is a full text term (word) that is:

• Not a stop word
• Not in the index
• At least 3 characters long

Key features and use cases:

• Query correction: Improve search experience by suggesting corrections
• Typo handling: Handle common typing mistakes and misspellings
• Search enhancement: Increase search success rates
• User experience: Provide "did you mean" functionality

Time complexity: O(1)

Parameters:

index - the index with the indexed terms

query - the search query to check for spelling errors

Returns:

spell check result containing misspelled terms and their suggestions

Since:

6.8

See Also:

FT.SPELLCHECK, Spellchecking, ftSpellcheck(Object, Object, SpellCheckArgs), ftDictadd(Object, Object[]), ftDictdel(Object, Object[]), ftDictdump(Object)

ftSpellcheck

@Experimental
RedisFuture<SpellCheckResult<V>> ftSpellcheck(K index,
                                                            V query,
                                                            SpellCheckArgs<K,V> args)

Perform spelling correction on a query with additional options.

This command analyzes the query for misspelled terms and provides spelling suggestions with configurable options for distance, custom dictionaries, and dialect.

Available options:

• DISTANCE: Maximum Levenshtein distance for suggestions (default: 1, max: 4)
• TERMS INCLUDE: Include terms from custom dictionaries as suggestions
• TERMS EXCLUDE: Exclude terms from custom dictionaries from suggestions
• DIALECT: Specify dialect version for query execution

Time complexity: O(1)

Parameters:

index - the index with the indexed terms

query - the search query to check for spelling errors

args - the spellcheck arguments (distance, terms, dialect)

Returns:

spell check result containing misspelled terms and their suggestions

Since:

6.8

See Also:

FT.SPELLCHECK, Spellchecking, ftSpellcheck(Object, Object), ftDictadd(Object, Object[]), ftDictdel(Object, Object[]), ftDictdump(Object)

ftDictadd

@Experimental
RedisFuture<Long> ftDictadd(K dict,
                                          V... terms)

Add terms to a dictionary.

This command adds one or more terms to a dictionary. Dictionaries are used for storing custom stopwords, synonyms, and other term lists that can be referenced in search operations. The dictionary is created if it doesn't exist.

Key features and use cases:

• Stopwords: Create custom stopword lists for filtering
• Synonyms: Build synonym dictionaries for query expansion
• Custom terms: Store domain-specific terminology
• Blacklists: Maintain lists of prohibited terms

Time complexity: O(1)

Parameters:

dict - the dictionary name

terms - the terms to add to the dictionary

Returns:

the number of new terms that were added

Since:

6.8

See Also:

FT.DICTADD, Spellchecking, ftDictdel(Object, Object[]), ftDictdump(Object)

ftDictdel

@Experimental
RedisFuture<Long> ftDictdel(K dict,
                                          V... terms)

Delete terms from a dictionary.

This command removes one or more terms from a dictionary. Only exact matches will be removed from the dictionary. Non-existent terms are ignored.

Time complexity: O(1)

Parameters:

dict - the dictionary name

terms - the terms to delete from the dictionary

Returns:

the number of terms that were deleted

Since:

6.8

See Also:

FT.DICTDEL, ftDictadd(Object, Object[]), ftDictdump(Object)

ftDictdump

@Experimental
RedisFuture<List<V>> ftDictdump(K dict)

Dump all terms in a dictionary.

This command returns all terms stored in the specified dictionary. The terms are returned in no particular order.

Time complexity: O(N), where N is the size of the dictionary

Parameters:

dict - the dictionary name

Returns:

a list of all terms in the dictionary

Since:

6.8

See Also:

FT.DICTDUMP, ftDictadd(Object, Object[]), ftDictdel(Object, Object[])

ftExplain

@Experimental
RedisFuture<String> ftExplain(K index,
                                            V query)

Return the execution plan for a complex query.

This command returns a string representing the execution plan that Redis Search will use to execute the given query. This is useful for understanding how the query will be processed and for optimizing query performance.

Key features and use cases:

• Query optimization: Understand how queries are executed
• Performance analysis: Identify potential bottlenecks
• Debugging: Troubleshoot complex query behavior
• Learning: Understand Redis Search query processing

Time complexity: O(1)

Parameters:

index - the index name

query - the search query to explain

Returns:

the execution plan as a string

Since:

6.8

See Also:

FT.EXPLAIN, ftExplain(Object, Object, ExplainArgs), ftSearch(Object, Object)

ftExplain

@Experimental
RedisFuture<String> ftExplain(K index,
                                            V query,
                                            ExplainArgs<K,V> args)

Return the execution plan for a complex query with additional options.

This command returns a string representing the execution plan that Redis Search will use to execute the given query under the specified dialect version.

Available options:

• DIALECT: Specify dialect version for query execution

Time complexity: O(1)

Parameters:

index - the index name

query - the search query to explain

args - the explain arguments (dialect)

Returns:

the execution plan as a string

Since:

6.8

See Also:

FT.EXPLAIN, ftExplain(Object, Object), ftSearch(Object, Object)

ftList

@Experimental
RedisFuture<List<V>> ftList()

Return a list of all existing indexes.

This command returns an array with the names of all existing indexes in the database. This is useful for discovering available indexes and managing index lifecycle.

Key features and use cases:

• Index discovery: Find all available search indexes
• Management: List indexes for administrative operations
• Monitoring: Track index creation and deletion
• Debugging: Verify index existence

Time complexity: O(1)

Note: This is a temporary command (indicated by the underscore prefix). In the future, a SCAN-type command will be added for use when a database contains a large number of indices.

Returns:

a list of index names

Since:

6.8

See Also:

FT._LIST, #ftCreate(Object, CreateArgs, FieldArgs[]), ftDropindex(Object)

ftSyndump

@Experimental
RedisFuture<Map<V,List<V>>> ftSyndump(K index)

Dump synonym group contents.

This command returns the contents of a synonym group. Synonym groups are used to define terms that should be treated as equivalent during search operations.

Key features and use cases:

• Synonym management: View current synonym definitions
• Query expansion: Understand how terms are expanded
• Debugging: Verify synonym group contents
• Administration: Audit synonym configurations

Time complexity: O(1)

Parameters:

index - the index name

Returns:

a map where keys are synonym terms and values are lists of group IDs containing that synonym

Since:

6.8

See Also:

FT.SYNDUMP, ftSynupdate(Object, Object, Object[]), ftSynupdate(Object, Object, SynUpdateArgs, Object[])

ftSynupdate

@Experimental
RedisFuture<String> ftSynupdate(K index,
                                              V synonymGroupId,
                                              V... terms)

Update a synonym group with additional terms.

This command creates or updates a synonym group with the specified terms. All terms in a synonym group are treated as equivalent during search operations. The command triggers a scan of all documents by default.

Key features and use cases:

• Synonym creation: Define equivalent terms for search
• Query expansion: Improve search recall with synonyms
• Language support: Handle different languages and dialects
• Domain terminology: Map technical terms to common language

Time complexity: O(1)

Parameters:

index - the index name

synonymGroupId - the synonym group identifier

terms - the terms to add to the synonym group

Returns:

OK if executed correctly

Since:

6.8

See Also:

FT.SYNUPDATE, ftSynupdate(Object, Object, SynUpdateArgs, Object[]), ftSyndump(Object)

ftSynupdate

@Experimental
RedisFuture<String> ftSynupdate(K index,
                                              V synonymGroupId,
                                              SynUpdateArgs<K,V> args,
                                              V... terms)

Update a synonym group with additional terms and options.

This command creates or updates a synonym group with the specified terms and options. The SKIPINITIALSCAN option can be used to avoid scanning existing documents, affecting only documents indexed after the update.

Available options:

• SKIPINITIALSCAN: Skip scanning existing documents

Time complexity: O(1)

Parameters:

index - the index name

synonymGroupId - the synonym group identifier

args - the synupdate arguments (skipInitialScan)

terms - the terms to add to the synonym group

Returns:

OK if executed correctly

Since:

6.8

See Also:

FT.SYNUPDATE, ftSynupdate(Object, Object, Object[]), ftSyndump(Object)

ftSugadd

@Experimental
RedisFuture<Long> ftSugadd(K key,
                                         V suggestion,
                                         double score)

Add a suggestion string to an auto-complete suggestion dictionary.

This command adds a suggestion string to an auto-complete suggestion dictionary with a specified score. The auto-complete suggestion dictionary is disconnected from the index definitions and leaves creating and updating suggestions dictionaries to the user.

Key features and use cases:

• Auto-completion: Build type-ahead search functionality
• Search suggestions: Provide query suggestions to users
• Fuzzy matching: Support approximate string matching
• Weighted results: Control suggestion ranking with scores

Time complexity: O(1)

Parameters:

key - the suggestion dictionary key

suggestion - the suggestion string to index

score - the floating point number of the suggestion string's weight

Returns:

the current size of the suggestion dictionary after adding the suggestion

Since:

6.8

See Also:

FT.SUGADD, ftSugadd(Object, Object, double, SugAddArgs), ftSugget(Object, Object), ftSugdel(Object, Object), ftSuglen(Object)

ftSugadd

@Experimental
RedisFuture<Long> ftSugadd(K key,
                                         V suggestion,
                                         double score,
                                         SugAddArgs<K,V> args)

Add a suggestion string to an auto-complete suggestion dictionary with additional options.

This command adds a suggestion string to an auto-complete suggestion dictionary with a specified score and optional arguments for incremental updates and payload storage.

Time complexity: O(1)

Parameters:

key - the suggestion dictionary key

suggestion - the suggestion string to index

score - the floating point number of the suggestion string's weight

args - the suggestion add arguments (INCR, PAYLOAD)

Returns:

the current size of the suggestion dictionary after adding the suggestion

Since:

6.8

See Also:

FT.SUGADD, ftSugadd(Object, Object, double), ftSugget(Object, Object, SugGetArgs), ftSugdel(Object, Object), ftSuglen(Object)

ftSugdel

@Experimental
RedisFuture<Boolean> ftSugdel(K key,
                                            V suggestion)

Delete a string from a suggestion dictionary.

This command removes a suggestion string from an auto-complete suggestion dictionary. Only the exact string match will be removed from the dictionary.

Time complexity: O(1)

Parameters:

key - the suggestion dictionary key

suggestion - the suggestion string to delete

Returns:

true if the string was found and deleted, false otherwise

Since:

6.8

See Also:

FT.SUGDEL, ftSugadd(Object, Object, double), ftSugget(Object, Object), ftSuglen(Object)

ftSugget

@Experimental
RedisFuture<List<Suggestion<V>>> ftSugget(K key,
                                                        V prefix)

Get completion suggestions for a prefix.

This command retrieves completion suggestions for a prefix from an auto-complete suggestion dictionary. By default, it returns up to 5 suggestions that match the given prefix.

Time complexity: O(1)

Parameters:

key - the suggestion dictionary key

prefix - the prefix to complete on

Returns:

a list of suggestions matching the prefix

Since:

6.8

See Also:

FT.SUGGET, ftSugget(Object, Object, SugGetArgs), ftSugadd(Object, Object, double), ftSugdel(Object, Object), ftSuglen(Object)

ftSugget

@Experimental
RedisFuture<List<Suggestion<V>>> ftSugget(K key,
                                                        V prefix,
                                                        SugGetArgs<K,V> args)

Get completion suggestions for a prefix with additional options.

This command retrieves completion suggestions for a prefix from an auto-complete suggestion dictionary with optional arguments for fuzzy matching, score inclusion, payload inclusion, and result limiting.

Time complexity: O(1)

Parameters:

key - the suggestion dictionary key

prefix - the prefix to complete on

args - the suggestion get arguments (FUZZY, WITHSCORES, WITHPAYLOADS, MAX)

Returns:

a list of suggestions matching the prefix, optionally with scores and payloads

Since:

6.8

See Also:

FT.SUGGET, ftSugget(Object, Object), ftSugadd(Object, Object, double, SugAddArgs), ftSugdel(Object, Object), ftSuglen(Object)

ftSuglen

@Experimental
RedisFuture<Long> ftSuglen(K key)

Get the size of an auto-complete suggestion dictionary.

This command returns the current number of suggestions stored in the auto-complete suggestion dictionary.

Time complexity: O(1)

Parameters:

key - the suggestion dictionary key

Returns:

the current size of the suggestion dictionary

Since:

6.8

See Also:

FT.SUGLEN, ftSugadd(Object, Object, double), ftSugget(Object, Object), ftSugdel(Object, Object)

ftDropindex

@Experimental
RedisFuture<String> ftDropindex(K index)

Drop a search index without deleting the associated documents.

This command removes the search index and all its associated metadata, but preserves the original documents (hashes or JSON objects) that were indexed. This is the safe default behavior that allows you to recreate the index later without losing data.

Time complexity: O(1)

Parameters:

index - the index name, as a key

Returns:

"OK" if the index was successfully dropped

Since:

6.8

See Also:

FT.DROPINDEX, ftDropindex(Object, boolean), ftCreate(Object, List)

ftDropindex

@Experimental
RedisFuture<String> ftDropindex(K index,
                                              boolean deleteDocuments)

Drop a search index with optional document deletion.

This command removes the search index and optionally deletes all associated documents. When deleteDocuments is true, this operation becomes destructive and will permanently remove both the index and all indexed documents from Redis.

Asynchronous Behavior: If an index creation is still running (ftCreate(Object, List) is running asynchronously), only the document hashes that have already been indexed are deleted. Documents that are queued for indexing but not yet processed will remain in the database.

Time complexity: O(1) or O(N) if documents are deleted, where N is the number of keys in the keyspace

Parameters:

index - the index name, as a key

deleteDocuments - if true, delete the indexed documents as well; if false, preserve documents

Returns:

"OK" if the index was successfully dropped

Since:

6.8

See Also:

FT.DROPINDEX, ftDropindex(Object), ftCreate(Object, List)

ftSearch

@Experimental
RedisFuture<SearchReply<K,V>> ftSearch(K index,
                                                     V query)

Search the index with a textual query using default search options.

This command performs a full-text search on the specified index using the provided query string. It returns matching documents with their content and metadata. This is the basic search variant that uses default search behavior without additional filtering, sorting, or result customization.

The query follows RediSearch query syntax, supporting:

• Simple text search: "hello world" - searches for documents containing both terms
• Field-specific search: "@title:redis" - searches within specific fields
• Boolean operators: "redis AND search" or "redis | search"
• Phrase search: "\"exact phrase\"" - searches for exact phrase matches
• Wildcard search: "redi*" - prefix matching
• Numeric ranges: "@price:[100 200]" - numeric field filtering
• Geographic search: "@location:[lon lat radius unit]" - geo-spatial queries

Time complexity: O(N) where N is the number of results in the result set

Parameters:

index - the index name, as a key

query - the query string following RediSearch query syntax

Returns:

the result of the search command containing matching documents, see SearchReply

Since:

6.8

See Also:

FT.SEARCH, Query syntax, SearchReply, SearchArgs, ftSearch(Object, Object, SearchArgs)

ftSearch

@Experimental
RedisFuture<SearchReply<K,V>> ftSearch(K index,
                                                     V query,
                                                     SearchArgs<K,V> args)

Search the index with a textual query using advanced search options and filters.

This command performs a full-text search on the specified index with advanced configuration options provided through SearchArgs. This variant allows fine-grained control over search behavior, result formatting, filtering, sorting, and pagination.

The SearchArgs parameter enables you to specify:

• Result options: NOCONTENT, WITHSCORES, WITHPAYLOADS, WITHSORTKEYS
• Query behavior: VERBATIM (no stemming), NOSTOPWORDS
• Filtering: Numeric filters, geo filters, field filters
• Result customization: RETURN specific fields, SUMMARIZE, HIGHLIGHT
• Sorting and pagination: SORTBY, LIMIT offset and count
• Performance options: TIMEOUT, SLOP, INORDER
• Language and scoring: LANGUAGE, SCORER, EXPLAINSCORE

Performance Considerations:

• Use NOCONTENT when you only need document IDs
• Specify RETURN fields to limit data transfer
• Use SORTABLE fields for efficient sorting
• Apply filters to reduce result set size
• Use LIMIT for pagination to avoid large result sets

Time complexity: O(N) where N is the number of results in the result set. Complexity varies based on query type, filters, and sorting requirements.

Parameters:

index - the index name, as a key

query - the query string following RediSearch query syntax

args - the search arguments containing advanced options and filters

Returns:

the result of the search command containing matching documents and metadata, see SearchReply

Since:

6.8

See Also:

FT.SEARCH, Query syntax, Advanced concepts, SearchReply, SearchArgs, ftSearch(Object, Object)

ftAggregate

@Experimental
RedisFuture<AggregationReply<K,V>> ftAggregate(K index,
                                                             V query)

Run a search query on an index and perform basic aggregate transformations using default options.

This command executes a search query and applies aggregation operations to transform and analyze the results. Unlike ftSearch(Object, Object), which returns individual documents, FT.AGGREGATE processes the result set through a pipeline of transformations to produce analytical insights, summaries, and computed values.

This basic variant uses default aggregation behavior without additional pipeline operations. For advanced aggregations with grouping, sorting, filtering, and custom transformations, use ftAggregate(Object, Object, AggregateArgs).

Common use cases for aggregations include:

• Analytics: Count documents, calculate averages, find min/max values
• Reporting: Group data by categories, time periods, or geographic regions
• Data transformation: Apply mathematical functions, format dates, extract values
• Performance optimization: Process large datasets server-side instead of client-side

Time complexity: O(1) base complexity, but depends on the query and number of results processed

Parameters:

index - the index name, as a key

query - the base filtering query that retrieves documents for aggregation

Returns:

the result of the aggregate command containing processed results, see SearchReply

Since:

6.8

See Also:

FT.AGGREGATE, Aggregations, SearchReply, AggregateArgs, ftAggregate(Object, Object, AggregateArgs)

ftAggregate

@Experimental
RedisFuture<AggregationReply<K,V>> ftAggregate(K index,
                                                             V query,
                                                             AggregateArgs<K,V> args)

Run a search query on an index and perform advanced aggregate transformations with a processing pipeline.

This command executes a search query and applies a sophisticated aggregation pipeline to transform, group, sort, and analyze the results. The AggregateArgs parameter defines a series of operations that process the data server-side, enabling powerful analytics and data transformation capabilities directly within Redis.

The aggregation pipeline supports the following operations:

• LOAD: Load specific document attributes for processing
• GROUPBY: Group results by one or more properties
• REDUCE: Apply reduction functions (COUNT, SUM, AVG, MIN, MAX, etc.)
• SORTBY: Sort results by specified properties
• APPLY: Apply mathematical expressions and transformations
• FILTER: Filter results based on computed values
• LIMIT: Paginate results efficiently
• WITHCURSOR: Enable cursor-based pagination for large result sets

Performance Considerations:

• Use SORTABLE fields for efficient grouping and sorting operations
• Apply filters early in the pipeline to reduce processing overhead
• Use WITHCURSOR for large result sets to avoid memory issues
• Load only necessary attributes to minimize data transfer
• Consider using LIMIT to restrict result set size

Time complexity: Non-deterministic, depends on the query and aggregation operations performed. Generally linear to the number of results processed through the pipeline.

Parameters:

index - the index name, as a key

query - the base filtering query that retrieves documents for aggregation

args - the aggregate arguments defining the processing pipeline and operations

Returns:

the result of the aggregate command containing processed and transformed results, see SearchReply

Since:

6.8

See Also:

FT.AGGREGATE, Aggregations, Cursor API, SearchReply, AggregateArgs, ftAggregate(Object, Object), ftCursorread(Object, long)

ftCursorread

@Experimental
RedisFuture<AggregationReply<K,V>> ftCursorread(K index,
                                                              long cursorId,
                                                              int count)

Read next results from an existing cursor.

This command is used to read the next batch of results from a cursor created by ftAggregate(Object, Object, AggregateArgs) with the WITHCURSOR option. Cursors provide an efficient way to iterate through large result sets without loading all results into memory at once.

The count parameter overrides the COUNT value specified in the original FT.AGGREGATE command, allowing you to control the batch size for this specific read operation.

Time complexity: O(1)

Parameters:

index - the index name, as a key

cursorId - the cursor id obtained from a previous FT.AGGREGATE or FT.CURSOR READ command

count - the number of results to read. This parameter overrides the COUNT specified in FT.AGGREGATE

Returns:

the result of the cursor read command containing the next batch of results and potentially a new cursor id, see SearchReply

Since:

6.8

See Also:

FT.CURSOR READ, Cursor API, SearchReply, ftAggregate(Object, Object, AggregateArgs)

ftCursorread

@Experimental
RedisFuture<AggregationReply<K,V>> ftCursorread(K index,
                                                              long cursorId)

Read next results from an existing cursor using the default batch size.

This command is used to read the next batch of results from a cursor created by ftAggregate(Object, Object, AggregateArgs) with the WITHCURSOR option. This variant uses the default batch size that was specified in the original FT.AGGREGATE command's WITHCURSOR clause.

Cursors provide an efficient way to iterate through large result sets without loading all results into memory at once. When the cursor is exhausted (no more results), the returned SearchReply will have a cursor id of 0.

Time complexity: O(1)

Parameters:

index - the index name, as a key

cursorId - the cursor id obtained from a previous FT.AGGREGATE or FT.CURSOR READ command

Returns:

the result of the cursor read command containing the next batch of results and potentially a new cursor id, see SearchReply

Since:

6.8

See Also:

FT.CURSOR READ, Cursor API, SearchReply, ftAggregate(Object, Object, AggregateArgs)

ftCursordel

@Experimental
RedisFuture<String> ftCursordel(K index,
                                              long cursorId)

Delete a cursor and free its associated resources.

This command is used to explicitly delete a cursor created by ftAggregate(Object, Object, AggregateArgs) with the WITHCURSOR option. Deleting a cursor frees up server resources and should be done when you no longer need to read more results from the cursor.

Important: Cursors have a default timeout and will be automatically deleted by Redis if not accessed within the timeout period. However, it's good practice to explicitly delete cursors when you're finished with them to free up resources immediately.

Once a cursor is deleted, any subsequent attempts to read from it using ftCursorread(Object, long) or ftCursorread(Object, long, int) will result in an error.

Time complexity: O(1)

Parameters:

index - the index name, as a key

cursorId - the cursor id obtained from a previous FT.AGGREGATE or FT.CURSOR READ command

Returns:

"OK" if the cursor was successfully deleted

Since:

6.8

See Also:

FT.CURSOR DEL, Cursor API, ftAggregate(Object, Object, AggregateArgs), ftCursorread(Object, long), ftCursorread(Object, long, int)