Implements a table that creates and maintains indexes on values stored within a configured set of column names.

This dataset uses two tables:

the actual data table, which stores the raw, unmodified rows which are written; and

an index table, with rows keyed by the indexed column and value (plus data row key for uniqueness),
which contains a reference to the row key in the data table matching the indexed value.

The indexed values need not be unique. When reading the data back by index value, a Scanner will be
returned, allowing the client to iterate through all matching rows. Exact matches as well as range lookups on
indexed values are supported.

Index entries are created by storing additional rows in a second table. These index rows are keyed by
column name, column value, and original row key, each field separated by a single null byte delimiter. It is not
recommended that the name of an index column contains the null byte (this can cause a degradation in performance
of index reads).

The columns to index can be configured in the DatasetProperties used
when the dataset instance in created. Multiple column names should be listed as a comma-separated string
(with no spaces):

get

NOTE: Depending on the implementation of this interface and use-case, calling this method can be less
efficient than calling the same method with columns as parameters because it can require making a
round trip to the persistent store.

NOTE: objects that are passed in parameters can be re-used by underlying implementation and present
in returned data structures from this method.

get

Reads values for the rows and columns defined by the Get parameters. When running in distributed mode,
and retrieving multiple rows at the same time, this method should be preferred to multiple Table.get(Get)
calls, as the operations will be batched into a single remote call per server.

delete

NOTE: Depending on the implementation of this interface and use-case, calling this method can be less
efficient than calling the same method with columns as parameters because it can require a round trip to
the persistent store.

compareAndSwap

Perform a swap operation by primary key.
Parameters are as if they were on a non-indexed table.
Note that if the swap is on the secondary key column,
then the index must be updated; otherwise, this is a
pass-through to the underlying table.

true if compare and swap succeeded, false otherwise (stored value is different from expected)

incrementAndGet

public long incrementAndGet(byte[] row,
byte[] column,
long amount)

Increments (atomically) the specified row and column by the specified amount, and returns the new value.
Note that performing this operation on an indexed column will generally have a negative impact on performance,
since up to three writes will need to be performed for every increment (one removing the index for the previous,
pre-increment value, one adding the index for the incremented value, and one for the increment itself).

incrementAndGet

Increments (atomically) the specified row and columns by the specified amounts, and returns the new values.
Note that performing this operation on an indexed column will generally have a negative impact on performance,
since up to three writes will need to be performed for every increment (one removing the index for the previous,
pre-increment value, one adding the index for the incremented value, and one for the increment itself).

incrementAndGet

Increments (atomically) the specified row and columns by the specified amounts, and returns the new values.
Note that performing this operation on an indexed column will generally have a negative impact on performance,
since up to three writes will need to be performed for every increment (one removing the index for the previous,
pre-increment value, one adding the index for the incremented value, and one for the increment itself).

increment

public void increment(byte[] row,
byte[][] columns,
long[] amounts)

Increments (atomically) the specified row and columns by the specified amounts, without returning the new values.
Note that performing this operation on an indexed column throws IllegalArgumentException.

increment

Increments (atomically) the specified row and columns by the specified amounts, without returning the new values.
Note that performing this operation on an indexed column throws IllegalArgumentException.