com.algolia.search

Class Index<T>

java.lang.Object

com.algolia.search.AbstractIndex<T>

com.algolia.search.Index<T>

public class Index<T>
extends AbstractIndex<T>

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	Index.Attributes

Method Summary

Modifier and Type	Method and Description
CreateUpdateKey	addKey(ApiKey key) Add a key to this index
TaskIndexing	addObject(String objectID, T object) Add an object in this index with a unique identifier
TaskIndexing	addObject(T object) Add an object in this index
TaskSingleIndex	addObjects(List<T> objects) Add several objects
TaskSingleIndex	batch(List<BatchOperation> operations) Custom batch
Task	batchSynonyms(List<AbstractSynonym> synonyms) Add or Replace a list of synonyms, no forward to slaves, and no replacement
Task	batchSynonyms(List<AbstractSynonym> synonyms, boolean forwardToReplicas) Add or Replace a list of synonyms, no replacement
Task	batchSynonyms(List<AbstractSynonym> synonyms, boolean forwardToReplicas, boolean replaceExistingSynonyms) Add or Replace a list of synonyms
IndexIterable<T>	browse(Query query) Browse all the content of this index
IndexIterable<T>	browseFrom(Query query, String cursor) Browse all the content of this index
Task	clear() Delete the index content without removing settings and index specific API keys.
Task	clearSynonyms() Clear all synonyms and NOT forwarding it to the slaves
Task	clearSynonyms(boolean forwardToReplicas) Clears all synonyms
Task	copyTo(String dstIndexName) Copy an existing index
Task	delete() Deletes the index
void	deleteByQuery(Query query) Delete records matching a query, with a batch size of 1000, internally uses browse
void	deleteByQuery(Query query, int batchSize) Delete records matching a query, internally uses browse
DeleteKey	deleteKey(String key) Delete a key by name from this index
Task	deleteObject(String objectID) Delete an object from the index
TaskSingleIndex	deleteObjects(List<String> objectIDs) Delete objects from the index
Task	deleteSynonym(String synonymID) Deletes a synonym by ID and NOT forwarding it to the slaves
Task	deleteSynonym(String synonymID, boolean forwardToReplicas) Deletes a synonym
Optional<ApiKey>	getKey(String key) Get a key by name from this index
Class<T>	getKlass()
String	getName()
Optional<T>	getObject(String objectID) Get an object from this index
List<T>	getObjects(List<String> objectIDs) Get several objects from this index
List<T>	getObjects(List<String> objectIDs, List<String> attributesToRetrieve) Get several objects from this index
IndexSettings	getSettings() Get settings of this index
Optional<AbstractSynonym>	getSynonym(String synonymID) Get a synonym by ID
List<ApiKey>	listKeys() List keys of this index
Task	moveTo(String dstIndexName) Moves an existing index
TaskSingleIndex	partialUpdateObject(PartialUpdateOperation operation) Partially update an object, create the object if it does not exist
TaskSingleIndex	partialUpdateObject(PartialUpdateOperation operation, boolean createIfNotExists) Partially update an object
TaskSingleIndex	partialUpdateObject(String objectID, Object object) Partially update an object
TaskSingleIndex	partialUpdateObjects(List<Object> objects) Partially update a objects
Task	saveObject(String objectID, T object) Override the content of object
TaskSingleIndex	saveObjects(List<T> objects) Override the content the list of objects
Task	saveSynonym(String synonymID, AbstractSynonym content) Saves/updates a synonym without replacing it and NOT forwarding it to the slaves
Task	saveSynonym(String synonymID, AbstractSynonym content, boolean forwardToReplicas) Saves/updates a synonym without replacing
Task	saveSynonym(String synonymID, AbstractSynonym content, boolean forwardToReplicas, boolean replaceExistingSynonyms) Saves/updates a synonym
SearchResult<T>	search(Query query) Search in the index throws a AlgoliaIndexNotFoundException if the index does not exists
SearchSynonymResult	searchSynonyms(SynonymQuery query) Search for synonyms
Task	setSettings(IndexSettings settings) Set settings of this index, and do not forward to slaves
Task	setSettings(IndexSettings settings, Boolean forwardToReplicas) Set settings of this index
CreateUpdateKey	updateKey(String keyName, ApiKey key) Update a key by name from this index
void	waitTask(Task task) Wait for the completion of a task, for 100ms
void	waitTask(Task task, long timeToWait) Wait for the completion of a task

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Method Detail

getName

public String getName()

Specified by:

getName in class AbstractIndex<T>

getKlass

public Class<T> getKlass()

Specified by:

getKlass in class AbstractIndex<T>

addObject

public TaskIndexing addObject(@Nonnull
                              T object)
                       throws AlgoliaException

Add an object in this index

Parameters:

object - object to add

Returns:

the related Task

Throws:

AlgoliaException

addObject

public TaskIndexing addObject(@Nonnull
                              String objectID,
                              @Nonnull
                              T object)
                       throws AlgoliaException

Add an object in this index with a unique identifier

Parameters:

objectID - the objectID associated to this object (if this objectID already exist the old object will be overridden)

object - object to add

Returns:

the related Task

Throws:

AlgoliaException

addObjects

public TaskSingleIndex addObjects(@Nonnull
                                  List<T> objects)
                           throws AlgoliaException

Add several objects

Parameters:

objects - objects to add

Returns:

the related Task

Throws:

AlgoliaException

getObject

public Optional<T> getObject(@Nonnull
                             String objectID)
                      throws AlgoliaException

Get an object from this index

Parameters:

objectID - the unique identifier of the object to retrieve

Returns:

The object

Throws:

AlgoliaException

getObjects

public List<T> getObjects(@Nonnull
                          List<String> objectIDs)
                   throws AlgoliaException

Get several objects from this index

Parameters:

objectIDs - the list of unique identifier of objects to retrieve

Returns:

the list of objects

Throws:

AlgoliaException

getObjects

public List<T> getObjects(@Nonnull
                          List<String> objectIDs,
                          @Nonnull
                          List<String> attributesToRetrieve)
                   throws AlgoliaException

Get several objects from this index

Parameters:

objectIDs - the list of unique identifier of objects to retrieve

attributesToRetrieve - the list of attributes to retrieve for these objects

Returns:

the list of objects

Throws:

AlgoliaException

waitTask

public void waitTask(@Nonnull
                     Task task,
                     long timeToWait)
              throws AlgoliaException

Wait for the completion of a task

Parameters:

task - task to wait for

timeToWait - the time to wait in milliseconds

Throws:

AlgoliaException

waitTask

public void waitTask(@Nonnull
                     Task task)
              throws AlgoliaException

Wait for the completion of a task, for 100ms

Parameters:

task - task to wait for

Throws:

AlgoliaException

delete

public Task delete()
            throws AlgoliaException

Deletes the index

Returns:

the related Task

Throws:

AlgoliaException

clear

public Task clear()
           throws AlgoliaException

Delete the index content without removing settings and index specific API keys.

Returns:

the related Task

Throws:

AlgoliaException

saveObject

public Task saveObject(@Nonnull
                       String objectID,
                       @Nonnull
                       T object)
                throws AlgoliaException

Override the content of object

Parameters:

objectID - the unique identifier of the object to retrieve

object - the object to update

Returns:

the related Task

Throws:

AlgoliaException

saveObjects

public TaskSingleIndex saveObjects(@Nonnull
                                   List<T> objects)
                            throws AlgoliaException

Override the content the list of objects

Parameters:

objects - the list objects to update

Returns:

the related Task

Throws:

AlgoliaException

deleteObject

public Task deleteObject(@Nonnull
                         String objectID)
                  throws AlgoliaException

Delete an object from the index

Parameters:

objectID - the unique identifier of the object to retrieve

Returns:

the related Task

Throws:

AlgoliaException

deleteObjects

public TaskSingleIndex deleteObjects(@Nonnull
                                     List<String> objectIDs)
                              throws AlgoliaException

Delete objects from the index

Parameters:

objectIDs - the list of unique identifier of the object to retrieve

Returns:

the related Task

Throws:

AlgoliaException

getSettings

public IndexSettings getSettings()
                          throws AlgoliaException

Get settings of this index

Returns:

the settings

Throws:

AlgoliaException

setSettings

public Task setSettings(@Nonnull
                        IndexSettings settings)
                 throws AlgoliaException

Set settings of this index, and do not forward to slaves

Parameters:

settings - the settings to set

Returns:

the related Task

Throws:

AlgoliaException

setSettings

public Task setSettings(@Nonnull
                        IndexSettings settings,
                        @Nonnull
                        Boolean forwardToReplicas)
                 throws AlgoliaException

Set settings of this index

Parameters:

settings - the settings to set

forwardToReplicas - should these updates be forwarded to the slaves

Returns:

the related Task

Throws:

AlgoliaException

listKeys

public List<ApiKey> listKeys()
                      throws AlgoliaException

List keys of this index

Returns:

the list of keys

Throws:

AlgoliaException

getKey

public Optional<ApiKey> getKey(@Nonnull
                               String key)
                        throws AlgoliaException

Get a key by name from this index

Parameters:

key - the key name

Returns:

the key

Throws:

AlgoliaException

deleteKey

public DeleteKey deleteKey(@Nonnull
                           String key)
                    throws AlgoliaException

Delete a key by name from this index

Parameters:

key - the key name

Returns:

the deleted key

Throws:

AlgoliaException

addKey

public CreateUpdateKey addKey(@Nonnull
                              ApiKey key)
                       throws AlgoliaException

Add a key to this index

Parameters:

key - the key

Returns:

the created key

Throws:

AlgoliaException

updateKey

public CreateUpdateKey updateKey(@Nonnull
                                 String keyName,
                                 @Nonnull
                                 ApiKey key)
                          throws AlgoliaException

Update a key by name from this index

Parameters:

keyName - the key name

key - the key to update

Returns:

the updated key

Throws:

AlgoliaException

moveTo

public Task moveTo(@Nonnull
                   String dstIndexName)
            throws AlgoliaException

Moves an existing index

Parameters:

dstIndexName - the new index name that will contains a copy of srcIndexName (destination will be overriten if it already exist)

Returns:

The task associated

Throws:

AlgoliaException

copyTo

public Task copyTo(@Nonnull
                   String dstIndexName)
            throws AlgoliaException

Copy an existing index

Parameters:

dstIndexName - the new index name that will contains a copy of srcIndexName (destination will be overridden if it already exist)

Returns:

The task associated

Throws:

AlgoliaException

search

public SearchResult<T> search(@Nonnull
                              Query query)
                       throws AlgoliaException

Search in the index throws a AlgoliaIndexNotFoundException if the index does not exists

Parameters:

query - the query

Returns:

the result of the search

Throws:

AlgoliaException

batch

public TaskSingleIndex batch(@Nonnull
                             List<BatchOperation> operations)
                      throws AlgoliaException

Custom batch

All operations must have index name set to null

Parameters:

operations - the list of operations to perform on this index

Returns:

the associated task

Throws:

AlgoliaException

See Also:

& subclasses

partialUpdateObject

public TaskSingleIndex partialUpdateObject(@Nonnull
                                           String objectID,
                                           @Nonnull
                                           Object object)
                                    throws AlgoliaException

Partially update an object

Parameters:

objectID - the ID of object to update

object - the object to update

Returns:

the associated task

Throws:

AlgoliaException

See Also:

& subclasses

partialUpdateObjects

public TaskSingleIndex partialUpdateObjects(@Nonnull
                                            List<Object> objects)
                                     throws AlgoliaException

Partially update a objects

Parameters:

objects - the list of objects to update (with an objectID)

Returns:

the associated task

Throws:

AlgoliaException

partialUpdateObject

public TaskSingleIndex partialUpdateObject(@Nonnull
                                           PartialUpdateOperation operation)
                                    throws AlgoliaException

Partially update an object, create the object if it does not exist

Parameters:

operation - the operation to perform on this object

Returns:

the associated task

Throws:

AlgoliaException

See Also:

& subclasses

partialUpdateObject

public TaskSingleIndex partialUpdateObject(@Nonnull
                                           PartialUpdateOperation operation,
                                           boolean createIfNotExists)
                                    throws AlgoliaException

Partially update an object

Parameters:

operation - the operation to perform on this object

createIfNotExists - should the object be created or not

Returns:

the associated task

Throws:

AlgoliaException

See Also:

& subclasses

saveSynonym

public Task saveSynonym(@Nonnull
                        String synonymID,
                        @Nonnull
                        AbstractSynonym content)
                 throws AlgoliaException

Saves/updates a synonym without replacing it and NOT forwarding it to the slaves

Parameters:

synonymID - the id of the synonym

content - the synonym

Returns:

the associated task

Throws:

AlgoliaException

saveSynonym

public Task saveSynonym(@Nonnull
                        String synonymID,
                        @Nonnull
                        AbstractSynonym content,
                        boolean forwardToReplicas)
                 throws AlgoliaException

Saves/updates a synonym without replacing

Parameters:

synonymID - the id of the synonym

content - the synonym

forwardToReplicas - should this request be forwarded to slaves

Returns:

the associated task

Throws:

AlgoliaException

saveSynonym

public Task saveSynonym(@Nonnull
                        String synonymID,
                        @Nonnull
                        AbstractSynonym content,
                        boolean forwardToReplicas,
                        boolean replaceExistingSynonyms)
                 throws AlgoliaException

Saves/updates a synonym

Parameters:

synonymID - the id of the synonym

content - the synonym

forwardToReplicas - should this request be forwarded to slaves

replaceExistingSynonyms - should replace if this synonyms exists

Returns:

the associated task

Throws:

AlgoliaException

getSynonym

public Optional<AbstractSynonym> getSynonym(@Nonnull
                                            String synonymID)
                                     throws AlgoliaException

Get a synonym by ID

Parameters:

synonymID - the id of the synonym

Returns:

the associated task

Throws:

AlgoliaException

deleteSynonym

public Task deleteSynonym(@Nonnull
                          String synonymID)
                   throws AlgoliaException

Deletes a synonym by ID and NOT forwarding it to the slaves

Parameters:

synonymID - the id of the synonym

Returns:

the associated task

Throws:

AlgoliaException

deleteSynonym

public Task deleteSynonym(@Nonnull
                          String synonymID,
                          boolean forwardToReplicas)
                   throws AlgoliaException

Deletes a synonym

Parameters:

synonymID - the id of the synonym

forwardToReplicas - should this request be forwarded to slaves

Returns:

the associated task

Throws:

AlgoliaException

clearSynonyms

public Task clearSynonyms()
                   throws AlgoliaException

Clear all synonyms and NOT forwarding it to the slaves

Returns:

the associated task

Throws:

AlgoliaException

clearSynonyms

public Task clearSynonyms(boolean forwardToReplicas)
                   throws AlgoliaException

Clears all synonyms

Returns:

the associated task

Throws:

AlgoliaException

searchSynonyms

public SearchSynonymResult searchSynonyms(@Nonnull
                                          SynonymQuery query)
                                   throws AlgoliaException

Search for synonyms

Parameters:

query - the query

Returns:

the results of the query

Throws:

AlgoliaException

batchSynonyms

public Task batchSynonyms(@Nonnull
                          List<AbstractSynonym> synonyms,
                          boolean forwardToReplicas,
                          boolean replaceExistingSynonyms)
                   throws AlgoliaException

Add or Replace a list of synonyms

Parameters:

synonyms - List of synonyms

forwardToReplicas - Forward the operation to the slave indices

replaceExistingSynonyms - Replace the existing synonyms with this batch

Returns:

the associated task

Throws:

AlgoliaException

batchSynonyms

public Task batchSynonyms(@Nonnull
                          List<AbstractSynonym> synonyms,
                          boolean forwardToReplicas)
                   throws AlgoliaException

Add or Replace a list of synonyms, no replacement

Parameters:

synonyms - List of synonyms

forwardToReplicas - Forward the operation to the slave indices

Returns:

the associated task

Throws:

AlgoliaException

batchSynonyms

public Task batchSynonyms(@Nonnull
                          List<AbstractSynonym> synonyms)
                   throws AlgoliaException

Add or Replace a list of synonyms, no forward to slaves, and no replacement

Parameters:

synonyms - List of synonyms

Returns:

the associated task

Throws:

AlgoliaException

browse

public IndexIterable<T> browse(@Nonnull
                               Query query)
                        throws AlgoliaException

Browse all the content of this index

Parameters:

query - The query to use to browse

Returns:

the iterator on top of this index

Throws:

AlgoliaException

browseFrom

public IndexIterable<T> browseFrom(@Nonnull
                                   Query query,
                                   @Nullable
                                   String cursor)
                            throws AlgoliaException

Browse all the content of this index

Parameters:

query - The query to use to browse

cursor - the cursor to start from

Returns:

the iterator on top of this index

Throws:

AlgoliaException

deleteByQuery

public void deleteByQuery(@Nonnull
                          Query query)
                   throws AlgoliaException

Delete records matching a query, with a batch size of 1000, internally uses browse

Parameters:

query - The query

Throws:

AlgoliaException

deleteByQuery

public void deleteByQuery(@Nonnull
                          Query query,
                          int batchSize)
                   throws AlgoliaException

Delete records matching a query, internally uses browse

Parameters:

query - The query

batchSize - the size of the batches

Throws:

AlgoliaException