org.redisson.api.RSearchAsync Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of redisson-all Show documentation
Easy Redis Java client and Real-Time Data Platform. Valkey compatible. Sync/Async/RxJava3/Reactive API. Client side caching. Over 50 Redis based Java objects and services: JCache API, Apache Tomcat, Hibernate, Spring, Set, Multimap, SortedSet, Map, List, Queue, Deque, Semaphore, Lock, AtomicLong, Map Reduce, Bloom filter, Scheduler, RPC
There is a newer version: 3.40.2
Show newest version
/**
 * Copyright (c) 2013-2024 Nikita Koksharov
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *    http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.redisson.api;

import org.redisson.api.search.SpellcheckOptions;
import org.redisson.api.search.aggregate.AggregationOptions;
import org.redisson.api.search.aggregate.AggregationResult;
import org.redisson.api.search.index.FieldIndex;
import org.redisson.api.search.index.IndexInfo;
import org.redisson.api.search.index.IndexOptions;
import org.redisson.api.search.query.QueryOptions;
import org.redisson.api.search.query.SearchResult;

import java.util.List;
import java.util.Map;

/**
 * Asynchronous API for RediSearch module
 *
 * @author Nikita Koksharov
 *
 */
public interface RSearchAsync {

    /**
     * Creates an index.
     * 
     * Code example:
     * 
     *             search.create("idx", IndexOptions.defaults()
     *                                     .on(IndexType.HASH)
     *                                     .prefix(Arrays.asList("doc:")),
     *                                     FieldIndex.text("t1"),
     *                                     FieldIndex.tag("t2").withSuffixTrie());
     * 
     *
     * @param indexName index name
     * @param options index options
     * @param fields fields
     */
    RFuture createIndexAsync(String indexName, IndexOptions options, FieldIndex... fields);

    /**
     * Executes search over defined index using defined query.
     * 
     * Code example:
     * 
     * SearchResult r = s.search("idx", "*", QueryOptions.defaults()
     *                                                   .returnAttributes(new ReturnAttribute("t1"), new ReturnAttribute("t2")));
     * 
     *
     * @param indexName index name
     * @param query query value
     * @param options query options
     * @return search result
     */
    RFuture searchAsync(String indexName, String query, QueryOptions options);

    /**
     * Executes aggregation over defined index using defined query.
     * 
     * Code example:
     * 
     * AggregationResult r = s.aggregate("idx", "*", AggregationOptions.defaults()
     *                                                                 .load("t1", "t2"));
     * 
     *
     * @param indexName index name
     * @param query query value
     * @param options aggregation options
     * @return aggregation result
     */
    RFuture aggregateAsync(String indexName, String query, AggregationOptions options);

    /**
     * Adds alias to defined index name
     *
     * @param alias alias value
     * @param indexName index name
     */
    RFuture addAliasAsync(String alias, String indexName);

    /**
     * Deletes index alias
     *
     * @param alias alias value
     */
    RFuture delAliasAsync(String alias);

    /**
     * Adds alias to defined index name.
     * Re-assigns the alias if it was used before with a different index.
     *
     * @param alias alias value
     * @param indexName index name
     */
    RFuture updateAliasAsync(String alias, String indexName);

    /**
     * Adds a new attribute to the index
     *
     * @param indexName index name
     * @param skipInitialScan doesn't scan the index if true
     * @param fields field indexes
     */
    RFuture alterAsync(String indexName, boolean skipInitialScan, FieldIndex... fields);

    /**
     * Returns configuration map by defined parameter name
     *
     * @param parameter parameter name
     * @return configuration map
     */
    RFuture> getConfigAsync(String parameter);

    /**
     * Sets configuration value by the parameter name
     *
     * @param parameter parameter name
     * @param value parameter value
     */
    RFuture setConfigAsync(String parameter, String value);

    /**
     * Deletes cursor by index name and id
     *
     * @param indexName index name
     * @param cursorId cursor id
     */
    RFuture delCursorAsync(String indexName, long cursorId);

    /**
     * Returns next results by index name and cursor id
     *
     * @param indexName index name
     * @param cursorId cursor id
     * @return aggregation result
     */
    RFuture readCursorAsync(String indexName, long cursorId);

    /**
     * Returns next results by index name, cursor id and results size
     *
     * @param indexName index name
     * @param cursorId cursor id
     * @param count results size
     * @return aggregation result
     */
    RFuture readCursorAsync(String indexName, long cursorId, int count);

    /**
     * Adds defined terms to the dictionary
     *
     * @param dictionary dictionary name
     * @param terms terms
     * @return number of new terms
     */
    RFuture addDictAsync(String dictionary, String... terms);

    /**
     * Deletes defined terms from the dictionary
     *
     * @param dictionary dictionary name
     * @param terms terms
     * @return number of deleted terms
     */
    RFuture delDictAsync(String dictionary, String... terms);

    /**
     * Returns terms stored in the dictionary
     *
     * @param dictionary dictionary name
     * @return terms
     */
    RFuture> dumpDictAsync(String dictionary);

    /**
     * Deletes index by name and associated documents.
     * Associated documents are deleted asynchronously.
     * Method {@link #infoAsync(String)} can be used to check for process completion.
     *
     * @param indexName index name
     */
    RFuture dropIndexAsync(String indexName);

    /**
     * Deletes index by name and associated documents
     *
     * @param indexName index name
     */
    RFuture dropIndexAndDocumentsAsync(String indexName);

    /**
     * Returns index info by name
     *
     * @param indexName index name
     * @return index info
     */
    RFuture infoAsync(String indexName);

    /**
     * Executes spell checking by defined index name and query.
     * Returns a map of misspelled terms and their score.
     *
     *      * Map> res = s.spellcheck("idx", "Hocke sti", SpellcheckOptions.defaults()
     *                                                                                          .includedTerms("name"));
     * 
     *
     * @param indexName index name
     * @param query query
     * @param options spell checking options
     * @return map of misspelled terms and their score
     */
    RFuture>> spellcheckAsync(String indexName, String query, SpellcheckOptions options);

    /**
     * Returns synonyms mapped by word by defined index name
     *
     * @param indexName index name
     * @return synonyms map
     */
    RFuture>> dumpSynonymsAsync(String indexName);

    /**
     * Updates synonyms
     *
     * @param indexName index name
     * @param synonymGroupId synonym group id
     * @param terms terms
     */
    RFuture updateSynonymsAsync(String indexName, String synonymGroupId, String... terms);

    /**
     * Returns list of all created indexes
     *
     * @return list of indexes
     */
    RFuture> getIndexesAsync();

}