org.apache.hadoop.hbase.rest.client
Class RemoteHTable

java.lang.Object
  extended by org.apache.hadoop.hbase.rest.client.RemoteHTable
All Implemented Interfaces:
Closeable, HTableInterface

@InterfaceAudience.Public
@InterfaceStability.Stable
public class RemoteHTable
extends Object
implements HTableInterface

HTable interface to remote tables accessed via REST gateway


Constructor Summary
RemoteHTable(Client client, org.apache.hadoop.conf.Configuration conf, byte[] name)
          Constructor
RemoteHTable(Client client, org.apache.hadoop.conf.Configuration conf, String name)
          Constructor
RemoteHTable(Client client, String name)
          Constructor
 
Method Summary
 Result append(Append append)
          Appends values to one or more columns within a single row.
 Object[] batch(List<? extends Row> actions)
          Same as HTableInterface.batch(List, Object[]), but returns an array of results instead of using a results parameter reference.
 void batch(List<? extends Row> actions, Object[] results)
          Method that does a batch call on Deletes, Gets, Puts, Increments, Appends and RowMutations.
<R> Object[]
batchCallback(List<? extends Row> actions, Batch.Callback<R> callback)
          Same as HTableInterface.batch(List), but with a callback.
<R> void
batchCallback(List<? extends Row> actions, Object[] results, Batch.Callback<R> callback)
          Same as HTableInterface.batch(List, Object[]), but with a callback.
protected  CellSetModel buildModelFromPut(Put put)
           
protected  String buildMultiRowSpec(byte[][] rows, int maxVersions)
           
protected  Result[] buildResultFromModel(CellSetModel model)
           
protected  String buildRowSpec(byte[] row, Map familyMap, long startTime, long endTime, int maxVersions)
           
 boolean checkAndDelete(byte[] row, byte[] family, byte[] qualifier, byte[] value, Delete delete)
          Atomically checks if a row/family/qualifier value matches the expected value.
 boolean checkAndPut(byte[] row, byte[] family, byte[] qualifier, byte[] value, Put put)
          Atomically checks if a row/family/qualifier value matches the expected value.
 void close()
          Releases any resources held or pending changes in internal buffers.
 CoprocessorRpcChannel coprocessorService(byte[] row)
          Creates and returns a RpcChannel instance connected to the table region containing the specified row.
<T extends com.google.protobuf.Service,R>
Map<byte[],R>
coprocessorService(Class<T> service, byte[] startKey, byte[] endKey, Batch.Call<T,R> callable)
          Creates an instance of the given Service subclass for each table region spanning the range from the startKey row to endKey row (inclusive), and invokes the passed Batch.Call.call(T) method with each Service instance.
<T extends com.google.protobuf.Service,R>
void
coprocessorService(Class<T> service, byte[] startKey, byte[] endKey, Batch.Call<T,R> callable, Batch.Callback<R> callback)
          Creates an instance of the given Service subclass for each table region spanning the range from the startKey row to endKey row (inclusive), and invokes the passed Batch.Call.call(T) method with each Service instance.
 void delete(Delete delete)
          Deletes the specified cells/row.
 void delete(List<Delete> deletes)
          Deletes the specified cells/rows in bulk.
 boolean exists(Get get)
          Test for the existence of columns in the table, as specified by the Get.
 Boolean[] exists(List<Get> gets)
          exists(List) is really a list of get() calls.
 void flushCommits()
          Executes all the buffered Put operations.
 Result get(Get get)
          Extracts certain cells from a given row.
 Result[] get(List<Get> gets)
          Extracts certain cells from the given rows, in batch.
 org.apache.hadoop.conf.Configuration getConfiguration()
          Returns the Configuration object used by this instance.
 TableName getName()
          Gets the fully qualified table name instance of this table.
 Result getRowOrBefore(byte[] row, byte[] family)
          Return the row that matches row exactly, or the one that immediately precedes it.
 ResultScanner getScanner(byte[] family)
          Gets a scanner on the current table for the given family.
 ResultScanner getScanner(byte[] family, byte[] qualifier)
          Gets a scanner on the current table for the given family and qualifier.
 ResultScanner getScanner(Scan scan)
          Returns a scanner on the current table as specified by the Scan object.
 HTableDescriptor getTableDescriptor()
          Gets the table descriptor for this table.
 byte[] getTableName()
          Gets the name of this table.
 long getWriteBufferSize()
          Returns the maximum size in bytes of the write buffer for this HTable.
 Result increment(Increment increment)
          Increments one or more columns within a single row.
 long incrementColumnValue(byte[] row, byte[] family, byte[] qualifier, long amount)
          See HTableInterface.incrementColumnValue(byte[], byte[], byte[], long, Durability)
 long incrementColumnValue(byte[] row, byte[] family, byte[] qualifier, long amount, Durability durability)
          Atomically increments a column value.
 boolean isAutoFlush()
          Tells whether or not 'auto-flush' is turned on.
 void mutateRow(RowMutations rm)
          Performs multiple mutations atomically on a single row.
 void put(List<Put> puts)
          Puts some data in the table, in batch.
 void put(Put put)
          Puts some data in the table.
 void setAutoFlush(boolean autoFlush)
          See HTableInterface.setAutoFlush(boolean, boolean)
 void setAutoFlush(boolean autoFlush, boolean clearBufferOnFail)
          Turns 'auto-flush' on or off.
 void setWriteBufferSize(long writeBufferSize)
          Sets the size of the buffer in bytes.
 
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
 

Constructor Detail

RemoteHTable

public RemoteHTable(Client client,
                    String name)
Constructor

Parameters:
client -
name -

RemoteHTable

public RemoteHTable(Client client,
                    org.apache.hadoop.conf.Configuration conf,
                    String name)
Constructor

Parameters:
client -
conf -
name -

RemoteHTable

public RemoteHTable(Client client,
                    org.apache.hadoop.conf.Configuration conf,
                    byte[] name)
Constructor

Parameters:
client -
conf -
name -
Method Detail

buildRowSpec

protected String buildRowSpec(byte[] row,
                              Map familyMap,
                              long startTime,
                              long endTime,
                              int maxVersions)

buildMultiRowSpec

protected String buildMultiRowSpec(byte[][] rows,
                                   int maxVersions)

buildResultFromModel

protected Result[] buildResultFromModel(CellSetModel model)

buildModelFromPut

protected CellSetModel buildModelFromPut(Put put)

getTableName

public byte[] getTableName()
Description copied from interface: HTableInterface
Gets the name of this table.

Specified by:
getTableName in interface HTableInterface
Returns:
the table name.

getName

public TableName getName()
Description copied from interface: HTableInterface
Gets the fully qualified table name instance of this table.

Specified by:
getName in interface HTableInterface

getConfiguration

public org.apache.hadoop.conf.Configuration getConfiguration()
Description copied from interface: HTableInterface
Returns the Configuration object used by this instance.

The reference returned is not a copy, so any change made to it will affect this instance.

Specified by:
getConfiguration in interface HTableInterface

getTableDescriptor

public HTableDescriptor getTableDescriptor()
                                    throws IOException
Description copied from interface: HTableInterface
Gets the table descriptor for this table.

Specified by:
getTableDescriptor in interface HTableInterface
Throws:
IOException - if a remote or network exception occurs.

close

public void close()
           throws IOException
Description copied from interface: HTableInterface
Releases any resources held or pending changes in internal buffers.

Specified by:
close in interface Closeable
Specified by:
close in interface HTableInterface
Throws:
IOException - if a remote or network exception occurs.

get

public Result get(Get get)
           throws IOException
Description copied from interface: HTableInterface
Extracts certain cells from a given row.

Specified by:
get in interface HTableInterface
Parameters:
get - The object that specifies what data to fetch and from which row.
Returns:
The data coming from the specified row, if it exists. If the row specified doesn't exist, the Result instance returned won't contain any KeyValue, as indicated by Result.isEmpty().
Throws:
IOException - if a remote or network exception occurs.

get

public Result[] get(List<Get> gets)
             throws IOException
Description copied from interface: HTableInterface
Extracts certain cells from the given rows, in batch.

Specified by:
get in interface HTableInterface
Parameters:
gets - The objects that specify what data to fetch and from which rows.
Returns:
The data coming from the specified rows, if it exists. If the row specified doesn't exist, the Result instance returned won't contain any KeyValue, as indicated by Result.isEmpty(). If there are any failures even after retries, there will be a null in the results array for those Gets, AND an exception will be thrown.
Throws:
IOException - if a remote or network exception occurs.

exists

public boolean exists(Get get)
               throws IOException
Description copied from interface: HTableInterface
Test for the existence of columns in the table, as specified by the Get.

This will return true if the Get matches one or more keys, false if not.

This is a server-side call so it prevents any data from being transfered to the client.

Specified by:
exists in interface HTableInterface
Parameters:
get - the Get
Returns:
true if the specified Get matches one or more keys, false if not
Throws:
IOException - e

exists

public Boolean[] exists(List<Get> gets)
                 throws IOException
exists(List) is really a list of get() calls. Just use get().

Specified by:
exists in interface HTableInterface
Parameters:
gets - list of Get to test for the existence
Returns:
Array of Boolean true if the specified Get matches one or more keys, false if not
Throws:
IOException - e

put

public void put(Put put)
         throws IOException
Description copied from interface: HTableInterface
Puts some data in the table.

If isAutoFlush is false, the update is buffered until the internal buffer is full.

Specified by:
put in interface HTableInterface
Parameters:
put - The data to put.
Throws:
IOException - if a remote or network exception occurs.

put

public void put(List<Put> puts)
         throws IOException
Description copied from interface: HTableInterface
Puts some data in the table, in batch.

If isAutoFlush is false, the update is buffered until the internal buffer is full.

This can be used for group commit, or for submitting user defined batches. The writeBuffer will be periodically inspected while the List is processed, so depending on the List size the writeBuffer may flush not at all, or more than once.

Specified by:
put in interface HTableInterface
Parameters:
puts - The list of mutations to apply. The batch put is done by aggregating the iteration of the Puts over the write buffer at the client-side for a single RPC call.
Throws:
IOException - if a remote or network exception occurs.

delete

public void delete(Delete delete)
            throws IOException
Description copied from interface: HTableInterface
Deletes the specified cells/row.

Specified by:
delete in interface HTableInterface
Parameters:
delete - The object that specifies what to delete.
Throws:
IOException - if a remote or network exception occurs.

delete

public void delete(List<Delete> deletes)
            throws IOException
Description copied from interface: HTableInterface
Deletes the specified cells/rows in bulk.

Specified by:
delete in interface HTableInterface
Parameters:
deletes - List of things to delete. List gets modified by this method (in particular it gets re-ordered, so the order in which the elements are inserted in the list gives no guarantee as to the order in which the Deletes are executed).
Throws:
IOException - if a remote or network exception occurs. In that case the deletes argument will contain the Delete instances that have not be successfully applied.

flushCommits

public void flushCommits()
                  throws IOException
Description copied from interface: HTableInterface
Executes all the buffered Put operations.

This method gets called once automatically for every Put or batch of Puts (when put(List) is used) when HTableInterface.isAutoFlush() is true.

Specified by:
flushCommits in interface HTableInterface
Throws:
IOException - if a remote or network exception occurs.

getScanner

public ResultScanner getScanner(Scan scan)
                         throws IOException
Description copied from interface: HTableInterface
Returns a scanner on the current table as specified by the Scan object. Note that the passed Scan's start row and caching properties maybe changed.

Specified by:
getScanner in interface HTableInterface
Parameters:
scan - A configured Scan object.
Returns:
A scanner.
Throws:
IOException - if a remote or network exception occurs.

getScanner

public ResultScanner getScanner(byte[] family)
                         throws IOException
Description copied from interface: HTableInterface
Gets a scanner on the current table for the given family.

Specified by:
getScanner in interface HTableInterface
Parameters:
family - The column family to scan.
Returns:
A scanner.
Throws:
IOException - if a remote or network exception occurs.

getScanner

public ResultScanner getScanner(byte[] family,
                                byte[] qualifier)
                         throws IOException
Description copied from interface: HTableInterface
Gets a scanner on the current table for the given family and qualifier.

Specified by:
getScanner in interface HTableInterface
Parameters:
family - The column family to scan.
qualifier - The column qualifier to scan.
Returns:
A scanner.
Throws:
IOException - if a remote or network exception occurs.

isAutoFlush

public boolean isAutoFlush()
Description copied from interface: HTableInterface
Tells whether or not 'auto-flush' is turned on.

Specified by:
isAutoFlush in interface HTableInterface
Returns:
true if 'auto-flush' is enabled (default), meaning Put operations don't get buffered/delayed and are immediately executed.

getRowOrBefore

public Result getRowOrBefore(byte[] row,
                             byte[] family)
                      throws IOException
Description copied from interface: HTableInterface
Return the row that matches row exactly, or the one that immediately precedes it.

Specified by:
getRowOrBefore in interface HTableInterface
Parameters:
row - A row key.
family - Column family to include in the Result.
Throws:
IOException - if a remote or network exception occurs.

checkAndPut

public boolean checkAndPut(byte[] row,
                           byte[] family,
                           byte[] qualifier,
                           byte[] value,
                           Put put)
                    throws IOException
Description copied from interface: HTableInterface
Atomically checks if a row/family/qualifier value matches the expected value. If it does, it adds the put. If the passed value is null, the check is for the lack of column (ie: non-existance)

Specified by:
checkAndPut in interface HTableInterface
Parameters:
row - to check
family - column family to check
qualifier - column qualifier to check
value - the expected value
put - data to put if check succeeds
Returns:
true if the new put was executed, false otherwise
Throws:
IOException - e

checkAndDelete

public boolean checkAndDelete(byte[] row,
                              byte[] family,
                              byte[] qualifier,
                              byte[] value,
                              Delete delete)
                       throws IOException
Description copied from interface: HTableInterface
Atomically checks if a row/family/qualifier value matches the expected value. If it does, it adds the delete. If the passed value is null, the check is for the lack of column (ie: non-existance)

Specified by:
checkAndDelete in interface HTableInterface
Parameters:
row - to check
family - column family to check
qualifier - column qualifier to check
value - the expected value
delete - data to delete if check succeeds
Returns:
true if the new delete was executed, false otherwise
Throws:
IOException - e

increment

public Result increment(Increment increment)
                 throws IOException
Description copied from interface: HTableInterface
Increments one or more columns within a single row.

This operation does not appear atomic to readers. Increments are done under a single row lock, so write operations to a row are synchronized, but readers do not take row locks so get and scan operations can see this operation partially completed.

Specified by:
increment in interface HTableInterface
Parameters:
increment - object that specifies the columns and amounts to be used for the increment operations
Returns:
values of columns after the increment
Throws:
IOException - e

append

public Result append(Append append)
              throws IOException
Description copied from interface: HTableInterface
Appends values to one or more columns within a single row.

This operation does not appear atomic to readers. Appends are done under a single row lock, so write operations to a row are synchronized, but readers do not take row locks so get and scan operations can see this operation partially completed.

Specified by:
append in interface HTableInterface
Parameters:
append - object that specifies the columns and amounts to be used for the increment operations
Returns:
values of columns after the append operation (maybe null)
Throws:
IOException - e

incrementColumnValue

public long incrementColumnValue(byte[] row,
                                 byte[] family,
                                 byte[] qualifier,
                                 long amount)
                          throws IOException
Description copied from interface: HTableInterface
See HTableInterface.incrementColumnValue(byte[], byte[], byte[], long, Durability)

The Durability is defaulted to Durability.SYNC_WAL.

Specified by:
incrementColumnValue in interface HTableInterface
Parameters:
row - The row that contains the cell to increment.
family - The column family of the cell to increment.
qualifier - The column qualifier of the cell to increment.
amount - The amount to increment the cell with (or decrement, if the amount is negative).
Returns:
The new value, post increment.
Throws:
IOException - if a remote or network exception occurs.

incrementColumnValue

public long incrementColumnValue(byte[] row,
                                 byte[] family,
                                 byte[] qualifier,
                                 long amount,
                                 Durability durability)
                          throws IOException
Description copied from interface: HTableInterface
Atomically increments a column value. If the column value already exists and is not a big-endian long, this could throw an exception. If the column value does not yet exist it is initialized to amount and written to the specified column.

Setting durability to Durability.SKIP_WAL means that in a fail scenario you will lose any increments that have not been flushed.

Specified by:
incrementColumnValue in interface HTableInterface
Parameters:
row - The row that contains the cell to increment.
family - The column family of the cell to increment.
qualifier - The column qualifier of the cell to increment.
amount - The amount to increment the cell with (or decrement, if the amount is negative).
durability - The persistence guarantee for this increment.
Returns:
The new value, post increment.
Throws:
IOException - if a remote or network exception occurs.

batch

public void batch(List<? extends Row> actions,
                  Object[] results)
           throws IOException
Description copied from interface: HTableInterface
Method that does a batch call on Deletes, Gets, Puts, Increments, Appends and RowMutations. The ordering of execution of the actions is not defined. Meaning if you do a Put and a Get in the same HTableInterface.batch(java.util.List, java.lang.Object[]) call, you will not necessarily be guaranteed that the Get returns what the Put had put.

Specified by:
batch in interface HTableInterface
Parameters:
actions - list of Get, Put, Delete, Increment, Append, RowMutations objects
results - Empty Object[], same size as actions. Provides access to partial results, in case an exception is thrown. A null in the result array means that the call for that action failed, even after retries
Throws:
IOException

batch

public Object[] batch(List<? extends Row> actions)
               throws IOException
Description copied from interface: HTableInterface
Same as HTableInterface.batch(List, Object[]), but returns an array of results instead of using a results parameter reference.

Specified by:
batch in interface HTableInterface
Parameters:
actions - list of Get, Put, Delete, Increment, Append, RowMutations objects
Returns:
the results from the actions. A null in the return array means that the call for that action failed, even after retries
Throws:
IOException

batchCallback

public <R> void batchCallback(List<? extends Row> actions,
                              Object[] results,
                              Batch.Callback<R> callback)
                   throws IOException,
                          InterruptedException
Description copied from interface: HTableInterface
Same as HTableInterface.batch(List, Object[]), but with a callback.

Specified by:
batchCallback in interface HTableInterface
Throws:
IOException
InterruptedException

batchCallback

public <R> Object[] batchCallback(List<? extends Row> actions,
                                  Batch.Callback<R> callback)
                       throws IOException,
                              InterruptedException
Description copied from interface: HTableInterface
Same as HTableInterface.batch(List), but with a callback.

Specified by:
batchCallback in interface HTableInterface
Throws:
IOException
InterruptedException

coprocessorService

public CoprocessorRpcChannel coprocessorService(byte[] row)
Description copied from interface: HTableInterface
Creates and returns a RpcChannel instance connected to the table region containing the specified row. The row given does not actually have to exist. Whichever region would contain the row based on start and end keys will be used. Note that the row parameter is also not passed to the coprocessor handler registered for this protocol, unless the row is separately passed as an argument in the service request. The parameter here is only used to locate the region used to handle the call.

The obtained RpcChannel instance can be used to access a published coprocessor Service using standard protobuf service invocations:

 CoprocessorRpcChannel channel = myTable.coprocessorService(rowkey);
 MyService.BlockingInterface service = MyService.newBlockingStub(channel);
 MyCallRequest request = MyCallRequest.newBuilder()
     ...
     .build();
 MyCallResponse response = service.myCall(null, request);
 

Specified by:
coprocessorService in interface HTableInterface
Parameters:
row - The row key used to identify the remote region location
Returns:
A CoprocessorRpcChannel instance

coprocessorService

public <T extends com.google.protobuf.Service,R> Map<byte[],R> coprocessorService(Class<T> service,
                                                                                  byte[] startKey,
                                                                                  byte[] endKey,
                                                                                  Batch.Call<T,R> callable)
                                 throws com.google.protobuf.ServiceException,
                                        Throwable
Description copied from interface: HTableInterface
Creates an instance of the given Service subclass for each table region spanning the range from the startKey row to endKey row (inclusive), and invokes the passed Batch.Call.call(T) method with each Service instance.

Specified by:
coprocessorService in interface HTableInterface
Type Parameters:
T - the Service subclass to connect to
R - Return type for the callable parameter's Batch.Call.call(T) method
Parameters:
service - the protocol buffer Service implementation to call
startKey - start region selection with region containing this row. If null, the selection will start with the first table region.
endKey - select regions up to and including the region containing this row. If null, selection will continue through the last table region.
callable - this instance's Batch.Call.call(T) method will be invoked once per table region, using the Service instance connected to that region.
Returns:
a map of result values keyed by region name
Throws:
com.google.protobuf.ServiceException
Throwable

coprocessorService

public <T extends com.google.protobuf.Service,R> void coprocessorService(Class<T> service,
                                                                         byte[] startKey,
                                                                         byte[] endKey,
                                                                         Batch.Call<T,R> callable,
                                                                         Batch.Callback<R> callback)
                        throws com.google.protobuf.ServiceException,
                               Throwable
Description copied from interface: HTableInterface
Creates an instance of the given Service subclass for each table region spanning the range from the startKey row to endKey row (inclusive), and invokes the passed Batch.Call.call(T) method with each Service instance.

The given Batch.Callback.update(byte[], byte[], Object) method will be called with the return value from each region's Batch.Call.call(T) invocation.

Specified by:
coprocessorService in interface HTableInterface
Type Parameters:
T - the Service subclass to connect to
R - Return type for the callable parameter's Batch.Call.call(T) method
Parameters:
service - the protocol buffer Service implementation to call
startKey - start region selection with region containing this row. If null, the selection will start with the first table region.
endKey - select regions up to and including the region containing this row. If null, selection will continue through the last table region.
callable - this instance's Batch.Call.call(T) method will be invoked once per table region, using the Service instance connected to that region.
Throws:
com.google.protobuf.ServiceException
Throwable

mutateRow

public void mutateRow(RowMutations rm)
               throws IOException
Description copied from interface: HTableInterface
Performs multiple mutations atomically on a single row. Currently Put and Delete are supported.

Specified by:
mutateRow in interface HTableInterface
Parameters:
rm - object that specifies the set of mutations to perform atomically
Throws:
IOException

setAutoFlush

public void setAutoFlush(boolean autoFlush)
Description copied from interface: HTableInterface
See HTableInterface.setAutoFlush(boolean, boolean)

Specified by:
setAutoFlush in interface HTableInterface
Parameters:
autoFlush - Whether or not to enable 'auto-flush'.

setAutoFlush

public void setAutoFlush(boolean autoFlush,
                         boolean clearBufferOnFail)
Description copied from interface: HTableInterface
Turns 'auto-flush' on or off.

When enabled (default), Put operations don't get buffered/delayed and are immediately executed. Failed operations are not retried. This is slower but safer.

Turning off autoFlush means that multiple Puts will be accepted before any RPC is actually sent to do the write operations. If the application dies before pending writes get flushed to HBase, data will be lost.

When you turn #autoFlush off, you should also consider the clearBufferOnFail option. By default, asynchronous Put requests will be retried on failure until successful. However, this can pollute the writeBuffer and slow down batching performance. Additionally, you may want to issue a number of Put requests and call HTableInterface.flushCommits() as a barrier. In both use cases, consider setting clearBufferOnFail to true to erase the buffer after HTableInterface.flushCommits() has been called, regardless of success.

Specified by:
setAutoFlush in interface HTableInterface
Parameters:
autoFlush - Whether or not to enable 'auto-flush'.
clearBufferOnFail - Whether to keep Put failures in the writeBuffer
See Also:
HTableInterface.flushCommits()

getWriteBufferSize

public long getWriteBufferSize()
Description copied from interface: HTableInterface
Returns the maximum size in bytes of the write buffer for this HTable.

The default value comes from the configuration parameter hbase.client.write.buffer.

Specified by:
getWriteBufferSize in interface HTableInterface
Returns:
The size of the write buffer in bytes.

setWriteBufferSize

public void setWriteBufferSize(long writeBufferSize)
                        throws IOException
Description copied from interface: HTableInterface
Sets the size of the buffer in bytes.

If the new size is less than the current amount of data in the write buffer, the buffer gets flushed.

Specified by:
setWriteBufferSize in interface HTableInterface
Parameters:
writeBufferSize - The new write buffer size, in bytes.
Throws:
IOException - if a remote or network exception occurs.


Copyright © 2013 The Apache Software Foundation. All Rights Reserved.