com.basho.riak.client.core.query.indexes

Class RiakIndexes

java.lang.Object

com.basho.riak.client.core.query.indexes.RiakIndexes

All Implemented Interfaces:

Iterable<RiakIndex<?>>

public class RiakIndexes
extends Object
implements Iterable<RiakIndex<?>>

Container used to instantiate and Manage RiakIndex objects to be used with a RiakObject.

This container manages and allows for an arbitrary number and types of RiakIndexs to be used with a RiakObject.

Working with RiakIndexes

Data in Riak, including secondary indexes, is stored as raw bytes. The conversion to and from bytes is handled by the concrete RiakIndex implementations and all indexes are managed by this container.

Each concrete RiakIndex includes a hybrid builder class named Name. The methods of this class take an instance of that builder as an argument to allow for proper type inference and construction of RiakIndex objects to expose.

getIndex() will either return a reference to the existing RiakIndex or atomically add and return a new one. The returned reference is of the type provided by the Name and is the mutable index; changes are made directly to it.

 LongIntIndex myIndex = riakIndexes.getIndex(new LongIntIndex.Name("number_on_hand"));
 myIndex.removeAll();
 myIndex.add(6L);
 

Calls can be chained, allowing for easy addition or removal of values from an index.

 riakIndexes.getIndex(new StringBinIndex.Name("colors")).remove("blue").add("red");
 

Special note when using RawIndex

A RiakIndex is uniquely identified by its textual name and IndexType regardless of the concrete RiakIndex implementation being used to view or update it. This container enforces this uniqueness by being the source of all RiakIndex instances and managing them in a thread-safe way with atomic operations.

What this means is that any RiakIndex having the same name and Indextype will refer to the same index. This is only important to note if you are mixing access to the indexes using RawIndex. The test case copied below demonstrates the relation.

 public void wrapping()
 {
     // creates or fetches the BIN (_bin) index named "foo", adds a value to it  
     RawIndex index = indexes.getIndex(new RawIndex.Name("foo", IndexType.BIN));
     BinaryValue baw = BinaryValue.unsafeCreate("value".getBytes());
     index.add(baw);
       
     // fetches the previously created index as a StringBinIndex
     StringBinIndex wrapper = indexes.getIndex(new StringBinIndex.Name("foo"));

     // The references are to different objects
     assertNotSame(index, wrapper);
     // The two objects are equal ( index.equals(wrapper) == true )
     assertEquals(index, wrapper);
     // The value exists
     assertTrue(wrapper.hasValue("value"));
     
     // Removing the value via the StringBinIndex is reflected in the RawIndex
     wrapper.remove("value");
     assertFalse(index.hasValue(baw));
 }
 

Since:

2.0

Author:

Brian Roach

See Also:

RiakObject.getIndexes()

Thread Safety:

This is a thread safe container.

Constructor Summary

Constructors

Constructor and Description
RiakIndexes() Instantiates a new RiakIndexes object containing no RiakIndex objects

Method Summary

Methods

Modifier and Type	Method and Description
<V extends RiakIndex,T extends RiakIndex.Name<V>> V	getIndex(T name) Get the named RiakIndex
<T extends RiakIndex> boolean	hasIndex(RiakIndex.Name<T> name) Returns whether a specific RiakIndex is present
boolean	isEmpty() Returns whether any RiakIndex objects are present
Iterator<RiakIndex<?>>	iterator()
void	removeAllIndexes() Remove all indexes.
<V,T extends RiakIndex<V>> T	removeIndex(RiakIndex.Name<T> name) Remove the named RiakIndex
int	size() Return the number of indexes present

Methods inherited from class java.lang.Object

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

Constructor Detail

RiakIndexes

public RiakIndexes()

Instantiates a new RiakIndexes object containing no RiakIndex objects

Method Detail

size

public int size()

Return the number of indexes present

Returns:

the number of indexes

isEmpty

public boolean isEmpty()

Returns whether any RiakIndex objects are present

Returns:

true if there are indexes, false otherwise

hasIndex

public <T extends RiakIndex> boolean hasIndex(RiakIndex.Name<T> name)

Returns whether a specific RiakIndex is present

Parameters:

name - the RiakIndex.Name representing the index to check for

Returns:

true if the index is present, false otherwise

getIndex

public <V extends RiakIndex,T extends RiakIndex.Name<V>> V getIndex(T name)

Get the named RiakIndex

If the named index does not exist it is created and added to the container before being returned.

Parameters:

name - The RiakIndex.Name of the index to retrieve

Returns:

The requested index typed accordingly.

removeIndex

public <V,T extends RiakIndex<V>> T removeIndex(RiakIndex.Name<T> name)

Remove the named RiakIndex

Parameters:

name - the RiakIndex.Name representing the index to remove

Returns:

the removed RiakIndex (typed accordingly) if the index was present, null otherwise

removeAllIndexes

public void removeAllIndexes()

Remove all indexes.

iterator

public Iterator<RiakIndex<?>> iterator()

Specified by:

iterator in interface Iterable<RiakIndex<?>>