@InterfaceAudience.Public @InterfaceStability.Stable public class RemoteHTable extends Object implements HTableInterface
| Constructor and Description |
|---|
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
|
| Modifier and Type | Method and Description |
|---|---|
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. |
<R extends com.google.protobuf.Message> |
batchCoprocessorService(com.google.protobuf.Descriptors.MethodDescriptor method,
com.google.protobuf.Message request,
byte[] startKey,
byte[] endKey,
R responsePrototype)
Creates an instance of the given
Service subclass for each table
region spanning the range from the startKey row to endKey row (inclusive), all
the invocations to the same region server will be batched into one call. |
<R extends com.google.protobuf.Message> |
batchCoprocessorService(com.google.protobuf.Descriptors.MethodDescriptor method,
com.google.protobuf.Message request,
byte[] startKey,
byte[] endKey,
R responsePrototype,
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), all
the invocations to the same region server will be batched into one call. |
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 |
checkAndMutate(byte[] row,
byte[] family,
byte[] qualifier,
CompareFilter.CompareOp compareOp,
byte[] value,
RowMutations mutation)
Atomically checks if a row/family/qualifier value matches the expected val
If it does, it performs the row mutations.
|
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> |
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> |
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)
|
long |
incrementColumnValue(byte[] row,
byte[] family,
byte[] qualifier,
long amount,
boolean writeToWAL) |
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)
|
void |
setAutoFlush(boolean autoFlush,
boolean clearBufferOnFail)
Turns 'auto-flush' on or off.
|
void |
setAutoFlushTo(boolean autoFlush)
Set the autoFlush behavior, without changing the value of
clearBufferOnFail |
void |
setWriteBufferSize(long writeBufferSize)
Sets the size of the buffer in bytes.
|
public RemoteHTable(Client client, org.apache.hadoop.conf.Configuration conf, String name)
client - conf - name - public RemoteHTable(Client client, org.apache.hadoop.conf.Configuration conf, byte[] name)
client - conf - name - protected String buildRowSpec(byte[] row, Map familyMap, long startTime, long endTime, int maxVersions)
protected String buildMultiRowSpec(byte[][] rows, int maxVersions)
protected Result[] buildResultFromModel(CellSetModel model)
protected CellSetModel buildModelFromPut(Put put)
public byte[] getTableName()
HTableInterfacegetTableName in interface HTableInterfacepublic TableName getName()
HTableInterfacegetName in interface HTableInterfacepublic org.apache.hadoop.conf.Configuration getConfiguration()
HTableInterfaceConfiguration object used by this instance.
The reference returned is not a copy, so any change made to it will affect this instance.
getConfiguration in interface HTableInterfacepublic HTableDescriptor getTableDescriptor() throws IOException
HTableInterfacetable descriptor for this table.getTableDescriptor in interface HTableInterfaceIOException - if a remote or network exception occurs.public void close()
throws IOException
HTableInterfaceclose in interface Closeableclose in interface AutoCloseableclose in interface HTableInterfaceIOException - if a remote or network exception occurs.public Result get(Get get) throws IOException
HTableInterfaceget in interface HTableInterfaceget - The object that specifies what data to fetch and from which row.Result instance returned won't
contain any KeyValue, as indicated by Result.isEmpty().IOException - if a remote or network exception occurs.public Result[] get(List<Get> gets) throws IOException
HTableInterfaceget in interface HTableInterfacegets - The objects that specify what data to fetch and from which rows.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.IOException - if a remote or network exception occurs.public boolean exists(Get get) throws IOException
HTableInterfaceThis 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.
exists in interface HTableInterfaceget - the GetIOException - epublic Boolean[] exists(List<Get> gets) throws IOException
exists in interface HTableInterfacegets - list of Get to test for the existenceIOException - epublic void put(Put put) throws IOException
HTableInterface
If isAutoFlush is false, the update is buffered
until the internal buffer is full.
put in interface HTableInterfaceput - The data to put.IOException - if a remote or network exception occurs.public void put(List<Put> puts) throws IOException
HTableInterface
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.
put in interface HTableInterfaceputs - 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.IOException - if a remote or network exception occurs.public void delete(Delete delete) throws IOException
HTableInterfacedelete in interface HTableInterfacedelete - The object that specifies what to delete.IOException - if a remote or network exception occurs.public void delete(List<Delete> deletes) throws IOException
HTableInterfacedelete in interface HTableInterfacedeletes - 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).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.public void flushCommits()
throws IOException
HTableInterfacePut operations.
This method gets called once automatically for every Put or batch
of Puts (when put(List is used) when
HTableInterface.isAutoFlush() is true.
flushCommits in interface HTableInterfaceIOException - if a remote or network exception occurs.public ResultScanner getScanner(Scan scan) throws IOException
HTableInterfaceScan
object.
Note that the passed Scan's start row and caching properties
maybe changed.getScanner in interface HTableInterfacescan - A configured Scan object.IOException - if a remote or network exception occurs.public ResultScanner getScanner(byte[] family) throws IOException
HTableInterfacegetScanner in interface HTableInterfacefamily - The column family to scan.IOException - if a remote or network exception occurs.public ResultScanner getScanner(byte[] family, byte[] qualifier) throws IOException
HTableInterfacegetScanner in interface HTableInterfacefamily - The column family to scan.qualifier - The column qualifier to scan.IOException - if a remote or network exception occurs.public boolean isAutoFlush()
HTableInterfaceisAutoFlush in interface HTableInterfacetrue if 'auto-flush' is enabled (default), meaning
Put operations don't get buffered/delayed and are immediately
executed.public Result getRowOrBefore(byte[] row, byte[] family) throws IOException
HTableInterfacegetRowOrBefore in interface HTableInterfacerow - A row key.family - Column family to include in the Result.IOException - if a remote or network exception occurs.public boolean checkAndPut(byte[] row,
byte[] family,
byte[] qualifier,
byte[] value,
Put put)
throws IOException
HTableInterfacecheckAndPut in interface HTableInterfacerow - to checkfamily - column family to checkqualifier - column qualifier to checkvalue - the expected valueput - data to put if check succeedsIOException - epublic boolean checkAndDelete(byte[] row,
byte[] family,
byte[] qualifier,
byte[] value,
Delete delete)
throws IOException
HTableInterfacecheckAndDelete in interface HTableInterfacerow - to checkfamily - column family to checkqualifier - column qualifier to checkvalue - the expected valuedelete - data to delete if check succeedsIOException - epublic Result increment(Increment increment) throws IOException
HTableInterfaceThis 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.
increment in interface HTableInterfaceincrement - object that specifies the columns and amounts to be used
for the increment operationsIOException - epublic Result append(Append append) throws IOException
HTableInterfaceThis 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.
append in interface HTableInterfaceappend - object that specifies the columns and amounts to be used
for the increment operationsIOException - epublic long incrementColumnValue(byte[] row,
byte[] family,
byte[] qualifier,
long amount)
throws IOException
HTableInterfaceHTableInterface.incrementColumnValue(byte[], byte[], byte[], long, Durability)
The Durability is defaulted to Durability.SYNC_WAL.
incrementColumnValue in interface HTableInterfacerow - 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).IOException - if a remote or network exception occurs.public long incrementColumnValue(byte[] row,
byte[] family,
byte[] qualifier,
long amount,
Durability durability)
throws IOException
HTableInterfaceamount 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.
incrementColumnValue in interface HTableInterfacerow - 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.IOException - if a remote or network exception occurs.public void batch(List<? extends Row> actions, Object[] results) throws IOException
HTableInterfaceHTableInterface.batch(java.util.List<? extends org.apache.hadoop.hbase.client.Row>, java.lang.Object[]) call, you will not necessarily be
guaranteed that the Get returns what the Put had put.batch in interface HTableInterfaceactions - list of Get, Put, Delete, Increment, Append, RowMutations objectsresults - 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 retriesIOExceptionpublic Object[] batch(List<? extends Row> actions) throws IOException
HTableInterfaceHTableInterface.batch(List, Object[]), but returns an array of
results instead of using a results parameter reference.batch in interface HTableInterfaceactions - list of Get, Put, Delete, Increment, Append, RowMutations objectsIOExceptionpublic <R> void batchCallback(List<? extends Row> actions, Object[] results, Batch.Callback<R> callback) throws IOException, InterruptedException
HTableInterfaceHTableInterface.batch(List, Object[]), but with a callback.batchCallback in interface HTableInterfaceIOExceptionInterruptedExceptionpublic <R> Object[] batchCallback(List<? extends Row> actions, Batch.Callback<R> callback) throws IOException, InterruptedException
HTableInterfaceHTableInterface.batch(List), but with a callback.batchCallback in interface HTableInterfaceIOExceptionInterruptedExceptionpublic CoprocessorRpcChannel coprocessorService(byte[] row)
HTableInterfaceRpcChannel 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);
coprocessorService in interface HTableInterfacerow - The row key used to identify the remote region locationpublic <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
HTableInterfaceService 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.coprocessorService in interface HTableInterfaceT - the Service subclass to connect toR - Return type for the callable parameter's
Batch.Call.call(T) methodservice - the protocol buffer Service implementation to callstartKey - 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.com.google.protobuf.ServiceExceptionThrowablepublic <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
HTableInterfaceService 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.
coprocessorService in interface HTableInterfaceT - the Service subclass to connect toR - Return type for the callable parameter's
Batch.Call.call(T) methodservice - the protocol buffer Service implementation to callstartKey - 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.com.google.protobuf.ServiceExceptionThrowablepublic void mutateRow(RowMutations rm) throws IOException
HTableInterfacemutateRow in interface HTableInterfacerm - object that specifies the set of mutations to perform atomicallyIOExceptionpublic void setAutoFlush(boolean autoFlush)
HTableInterfacesetAutoFlush in interface HTableInterfaceautoFlush - Whether or not to enable 'auto-flush'.public void setAutoFlush(boolean autoFlush,
boolean clearBufferOnFail)
HTableInterface
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.
In other words, if you call #setAutoFlush(false); HBase will retry N time for each
flushCommit, including the last one when closing the table. This is NOT recommended,
most of the time you want to call #setAutoFlush(false, true).
setAutoFlush in interface HTableInterfaceautoFlush - Whether or not to enable 'auto-flush'.clearBufferOnFail - Whether to keep Put failures in the writeBuffer. If autoFlush is true, then
the value of this parameter is ignored and clearBufferOnFail is set to true.
Setting clearBufferOnFail to false is deprecated since 0.96.HTableInterface.flushCommits()public void setAutoFlushTo(boolean autoFlush)
HTableInterfaceclearBufferOnFailsetAutoFlushTo in interface HTableInterfacepublic long getWriteBufferSize()
HTableInterface
The default value comes from the configuration parameter
hbase.client.write.buffer.
getWriteBufferSize in interface HTableInterfacepublic void setWriteBufferSize(long writeBufferSize)
throws IOException
HTableInterfaceIf the new size is less than the current amount of data in the write buffer, the buffer gets flushed.
setWriteBufferSize in interface HTableInterfacewriteBufferSize - The new write buffer size, in bytes.IOException - if a remote or network exception occurs.public long incrementColumnValue(byte[] row,
byte[] family,
byte[] qualifier,
long amount,
boolean writeToWAL)
throws IOException
incrementColumnValue in interface HTableInterfaceIOExceptionpublic <R extends com.google.protobuf.Message> Map<byte[],R> batchCoprocessorService(com.google.protobuf.Descriptors.MethodDescriptor method, com.google.protobuf.Message request, byte[] startKey, byte[] endKey, R responsePrototype) throws com.google.protobuf.ServiceException, Throwable
HTableInterfaceService subclass for each table
region spanning the range from the startKey row to endKey row (inclusive), all
the invocations to the same region server will be batched into one call. The coprocessor
service is invoked according to the service instance, method name and parameters.batchCoprocessorService in interface HTableInterfaceR - the response type for the coprocessor Service methodmethod - the descriptor for the protobuf service method to call.request - the method call parametersstartKey - 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.responsePrototype - the proto type of the response of the method in Service.com.google.protobuf.ServiceExceptionThrowablepublic <R extends com.google.protobuf.Message> void batchCoprocessorService(com.google.protobuf.Descriptors.MethodDescriptor method,
com.google.protobuf.Message request,
byte[] startKey,
byte[] endKey,
R responsePrototype,
Batch.Callback<R> callback)
throws com.google.protobuf.ServiceException,
Throwable
HTableInterfaceService subclass for each table
region spanning the range from the startKey row to endKey row (inclusive), all
the invocations to the same region server will be batched into one call. The coprocessor
service is invoked according to the service instance, method name and parameters.
The given
Batch.Callback.update(byte[],byte[],Object)
method will be called with the return value from each region's invocation.
batchCoprocessorService in interface HTableInterfaceR - the response type for the coprocessor Service methodmethod - the descriptor for the protobuf service method to call.request - the method call parametersstartKey - 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.responsePrototype - the proto type of the response of the method in Service.callback - callback to invoke with the response for each regioncom.google.protobuf.ServiceExceptionThrowablepublic boolean checkAndMutate(byte[] row,
byte[] family,
byte[] qualifier,
CompareFilter.CompareOp compareOp,
byte[] value,
RowMutations mutation)
throws IOException
HTableInterfacecheckAndMutate in interface HTableInterfacerow - to checkfamily - column family to checkqualifier - column qualifier to checkcompareOp - the comparison operatorvalue - the expected valuemutation - mutations to perform if check succeedsIOException - eCopyright © 2014 The Apache Software Foundation. All rights reserved.