HTable (Apache HBase 2.5.0 API)

java.lang.Object
- org.apache.hadoop.hbase.client.HTable

All Implemented Interfaces:

Closeable, AutoCloseable, Table
```
@InterfaceAudience.Private
 @InterfaceStability.Stable
public class HTable
extends Object
implements Table
```
An implementation of Table. Used to communicate with a single HBase table. Lightweight. Get as needed and just close when done. Instances of this class SHOULD NOT be constructed directly. Obtain an instance via Connection. See ConnectionFactory class comment for an example of how.
This class is thread safe since 2.0.0 if not invoking any of the setter methods. All setters are moved into TableBuilder and reserved here only for keeping backward compatibility, and TODO will be removed soon.
HTable is no longer a client API. Use Table instead. It is marked InterfaceAudience.Private indicating that this is an HBase-internal class as defined in Hadoop Interface Classification There are no guarantees for backwards source / binary compatibility and methods or class can change or go away without deprecation.

See Also:

Table, Admin, Connection, ConnectionFactory

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

private class HTable.CheckAndMutateBuilderImpl

private class HTable.CheckAndMutateWithFilterBuilderImpl
- Nested classes/interfaces inherited from interface org.apache.hadoop.hbase.client.Table
  Table.CheckAndMutateBuilder, Table.CheckAndMutateWithFilterBuilder

Nested Classes
Modifier and Type	Class and Description
`private class`	`HTable.CheckAndMutateBuilderImpl`
`private class`	`HTable.CheckAndMutateWithFilterBuilderImpl`

Field Summary

Fields
Modifier and Type	Field and Description
`private boolean`	`cleanupPoolOnClose`
`private boolean`	`closed`
`private org.apache.hadoop.conf.Configuration`	`configuration`
`private ConnectionConfiguration`	`connConfiguration`
`private ClusterConnection`	`connection`
`private static Consistency`	`DEFAULT_CONSISTENCY`
`private HRegionLocator`	`locator`
`private static org.slf4j.Logger`	`LOG`
`(package private) AsyncProcess`	`multiAp` The Async process for batch
`private int`	`operationTimeoutMs`
`private ExecutorService`	`pool`
`private int`	`readRpcTimeoutMs`
`private RpcRetryingCallerFactory`	`rpcCallerFactory`
`private RpcControllerFactory`	`rpcControllerFactory`
`private int`	`rpcTimeoutMs`
`private int`	`scannerCaching`
`private long`	`scannerMaxResultSize`
`private int`	`scanReadRpcTimeout`
`private int`	`scanTimeout`
`private TableName`	`tableName`
`private int`	`writeRpcTimeoutMs`

Constructor Summary

Constructors
Modifier	Constructor and Description
`protected`	`HTable(ConnectionImplementation connection, TableBuilderBase builder, RpcRetryingCallerFactory rpcCallerFactory, RpcControllerFactory rpcControllerFactory, ExecutorService pool)` Creates an object to access a HBase table.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`Result`	`append(Append append)` Appends values to one or more columns within a single row.
`void`	`batch(List<? extends Row> actions, Object[] results)` Method that does a batch call on Deletes, Gets, Puts, Increments, Appends, RowMutations.
`void`	`batch(List<? extends Row> actions, Object[] results, int rpcTimeout)`
`<R> void`	`batchCallback(List<? extends Row> actions, Object[] results, Batch.Callback<R> callback)` Same as `Table.batch(List, Object[])`, but with a callback.
`<R extends com.google.protobuf.Message> Map<byte[],R>`	`batchCoprocessorService(com.google.protobuf.Descriptors.MethodDescriptor methodDescriptor, 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> void`	`batchCoprocessorService(com.google.protobuf.Descriptors.MethodDescriptor methodDescriptor, 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.
`boolean`	`checkAndDelete(byte[] row, byte[] family, byte[] qualifier, byte[] value, Delete delete)` Deprecated.
`boolean`	`checkAndDelete(byte[] row, byte[] family, byte[] qualifier, CompareFilter.CompareOp compareOp, byte[] value, Delete delete)` Deprecated.
`boolean`	`checkAndDelete(byte[] row, byte[] family, byte[] qualifier, CompareOperator op, byte[] value, Delete delete)` Deprecated.
`Table.CheckAndMutateBuilder`	`checkAndMutate(byte[] row, byte[] family)` Deprecated.
`boolean`	`checkAndMutate(byte[] row, byte[] family, byte[] qualifier, CompareFilter.CompareOp compareOp, byte[] value, RowMutations rm)` Deprecated.
`boolean`	`checkAndMutate(byte[] row, byte[] family, byte[] qualifier, CompareOperator op, byte[] value, RowMutations rm)` Deprecated.
`Table.CheckAndMutateWithFilterBuilder`	`checkAndMutate(byte[] row, Filter filter)` Deprecated.
`CheckAndMutateResult`	`checkAndMutate(CheckAndMutate checkAndMutate)` checkAndMutate that atomically checks if a row matches the specified condition.
`List<CheckAndMutateResult>`	`checkAndMutate(List<CheckAndMutate> checkAndMutates)` Batch version of checkAndMutate.
`boolean`	`checkAndPut(byte[] row, byte[] family, byte[] qualifier, byte[] value, Put put)` Deprecated.
`boolean`	`checkAndPut(byte[] row, byte[] family, byte[] qualifier, CompareFilter.CompareOp compareOp, byte[] value, Put put)` Deprecated.
`boolean`	`checkAndPut(byte[] row, byte[] family, byte[] qualifier, CompareOperator op, byte[] value, Put put)` Deprecated.
`void`	`clearRegionCache()` Explicitly clears the region cache to fetch the latest value from META.
`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)` Batch Deletes the specified cells/rows from the table.
`static <R> void`	`doBatchWithCallback(List<? extends Row> actions, Object[] results, Batch.Callback<R> callback, ClusterConnection connection, ExecutorService pool, TableName tableName)`
`private CheckAndMutateResult`	`doCheckAndMutate(byte[] row, byte[] family, byte[] qualifier, CompareOperator op, byte[] value, Filter filter, TimeRange timeRange, Mutation mutation)`
`private CheckAndMutateResult`	`doCheckAndMutate(byte[] row, byte[] family, byte[] qualifier, CompareOperator op, byte[] value, Filter filter, TimeRange timeRange, RowMutations rm)`
`boolean`	`exists(Get get)` Test for the existence of columns in the table, as specified by the Get.
`boolean[]`	`exists(List<Get> gets)` Test for the existence of columns in the table, as specified by the Gets.
`Result`	`get(Get get)` Extracts certain cells from a given row.
`private Result`	`get(Get get, boolean checkExistenceOnly)`
`Result[]`	`get(List<Get> gets)` Extracts specified cells from the given rows, as a batch.
`org.apache.hadoop.conf.Configuration`	`getConfiguration()` Returns the `Configuration` object used by this instance.
`protected Connection`	`getConnection()` INTERNAL Used by unit tests and tools to do low-level manipulations.
`static ThreadPoolExecutor`	`getDefaultExecutor(org.apache.hadoop.conf.Configuration conf)`
`TableDescriptor`	`getDescriptor()` Gets the `table descriptor` for this table.
`private Pair<List<byte[]>,List<HRegionLocation>>`	`getKeysAndRegionsInRange(byte[] startKey, byte[] endKey, boolean includeEndKey)` Get the corresponding start keys and regions for an arbitrary range of keys.
`private Pair<List<byte[]>,List<HRegionLocation>>`	`getKeysAndRegionsInRange(byte[] startKey, byte[] endKey, boolean includeEndKey, boolean reload)` Get the corresponding start keys and regions for an arbitrary range of keys.
`static int`	`getMaxKeyValueSize(org.apache.hadoop.conf.Configuration conf)` Returns maxKeyValueSize from configuration.
`TableName`	`getName()` Gets the fully qualified table name instance of this table.
`private long`	`getNonce()`
`private long`	`getNonceGroup()`
`int`	`getOperationTimeout()` Deprecated.
`long`	`getOperationTimeout(TimeUnit unit)` Get timeout of each operation in Table instance.
`(package private) ExecutorService`	`getPool()` The pool is used for mutli requests for this HTable
`int`	`getReadRpcTimeout()` Deprecated.
`long`	`getReadRpcTimeout(TimeUnit unit)` Get timeout of each rpc read request in this Table instance.
`RegionLocator`	`getRegionLocator()` Gets the `RegionLocator` for this table.
`int`	`getRpcTimeout()` Deprecated.
`long`	`getRpcTimeout(TimeUnit unit)` Get timeout of each rpc request in this Table instance.
`ResultScanner`	`getScanner(byte[] family)` The underlying `HTable` must not be closed.
`ResultScanner`	`getScanner(byte[] family, byte[] qualifier)` The underlying `HTable` must not be closed.
`ResultScanner`	`getScanner(Scan scan)` The underlying `HTable` must not be closed.
`private List<byte[]>`	`getStartKeysInRange(byte[] start, byte[] end)`
`HTableDescriptor`	`getTableDescriptor()` Deprecated.
`int`	`getWriteRpcTimeout()` Deprecated.
`long`	`getWriteRpcTimeout(TimeUnit unit)` Get timeout of each rpc write request in this Table instance.
`Result`	`increment(Increment increment)` Increments one or more columns within a single row.
`long`	`incrementColumnValue(byte[] row, byte[] family, byte[] qualifier, long amount)` See `Table.incrementColumnValue(byte[], byte[], byte[], long, Durability)`
`long`	`incrementColumnValue(byte[] row, byte[] family, byte[] qualifier, long amount, Durability durability)` Atomically increments a column value.
`Result`	`mutateRow(RowMutations rm)` Performs multiple mutations atomically on a single row.
`<R> void`	`processBatchCallback(List<? extends Row> list, Object[] results, Batch.Callback<R> callback)` Process a mixed batch of Get, Put and Delete actions.
`void`	`put(List<Put> puts)` Batch puts the specified data into the table.
`void`	`put(Put put)` Puts some data in the table.
`void`	`setOperationTimeout(int operationTimeout)` Deprecated.
`void`	`setReadRpcTimeout(int readRpcTimeout)` Deprecated.
`void`	`setRpcTimeout(int rpcTimeout)` Deprecated.
`void`	`setWriteRpcTimeout(int writeRpcTimeout)` Deprecated.
`private CompareOperator`	`toCompareOperator(CompareFilter.CompareOp compareOp)`
`String`	`toString()`
`private void`	`validatePut(Put put)`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Methods inherited from interface org.apache.hadoop.hbase.client.Table
existsAll

- Field Detail
  - LOG
```
private static final org.slf4j.Logger LOG
```
  - DEFAULT_CONSISTENCY
```
private static final Consistency DEFAULT_CONSISTENCY
```
  - connection
```
private final ClusterConnection connection
```
  - tableName
```
private final TableName tableName
```
  - configuration
```
private final org.apache.hadoop.conf.Configuration configuration
```
  - connConfiguration
```
private final ConnectionConfiguration connConfiguration
```
  - closed
```
private boolean closed
```
  - scannerCaching
```
private final int scannerCaching
```
  - scannerMaxResultSize
```
private final long scannerMaxResultSize
```
  - pool
```
private final ExecutorService pool
```
  - operationTimeoutMs
```
private int operationTimeoutMs
```
  - rpcTimeoutMs
```
private final int rpcTimeoutMs
```
  - readRpcTimeoutMs
```
private int readRpcTimeoutMs
```
  - writeRpcTimeoutMs
```
private int writeRpcTimeoutMs
```
  - scanReadRpcTimeout
```
private final int scanReadRpcTimeout
```
  - scanTimeout
```
private final int scanTimeout
```
  - cleanupPoolOnClose
```
private final boolean cleanupPoolOnClose
```
  - locator
```
private final HRegionLocator locator
```
  - multiAp
```
AsyncProcess multiAp
```
    The Async process for batch
  - rpcCallerFactory
```
private final RpcRetryingCallerFactory rpcCallerFactory
```
  - rpcControllerFactory
```
private final RpcControllerFactory rpcControllerFactory
```
- Constructor Detail
  - HTable
```
@InterfaceAudience.Private
protected HTable(ConnectionImplementation connection,
                                            TableBuilderBase builder,
                                            RpcRetryingCallerFactory rpcCallerFactory,
                                            RpcControllerFactory rpcControllerFactory,
                                            ExecutorService pool)
```
    Creates an object to access a HBase table. Used by HBase internally. DO NOT USE. See ConnectionFactory class comment for how to get a Table instance (use Table instead of HTable).
    
    Parameters:
    
    connection - Connection to be used.
    
    builder - The table builder
    
    rpcCallerFactory - The RPC caller factory
    
    rpcControllerFactory - The RPC controller factory
    
    pool - ExecutorService to be used.
- Method Detail
  - getDefaultExecutor
```
@InterfaceAudience.Private
public static ThreadPoolExecutor getDefaultExecutor(org.apache.hadoop.conf.Configuration conf)
```
  - getMaxKeyValueSize
```
public static int getMaxKeyValueSize(org.apache.hadoop.conf.Configuration conf)
```
    Returns maxKeyValueSize from configuration.
  - getConfiguration
```
public org.apache.hadoop.conf.Configuration getConfiguration()
```
    Description copied from interface: Table
    
    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 Table
  - getName
```
public TableName getName()
```
    Description copied from interface: Table
    
    Gets the fully qualified table name instance of this table.
    
    Specified by:
    
    getName in interface Table
  - getConnection
```
protected Connection getConnection()
```
    INTERNAL Used by unit tests and tools to do low-level manipulations.
    
    Returns:
    
    A Connection instance.
  - getTableDescriptor
```
@Deprecated
public HTableDescriptor getTableDescriptor()
                                                throws IOException
```
    Deprecated.
    
    Description copied from interface: Table
    
    Gets the table descriptor for this table.
    
    Specified by:
    
    getTableDescriptor in interface Table
    
    Throws:
    
    IOException - if a remote or network exception occurs.
  - getDescriptor
```
public TableDescriptor getDescriptor()
                              throws IOException
```
    Description copied from interface: Table
    
    Gets the table descriptor for this table.
    
    Specified by:
    
    getDescriptor in interface Table
    
    Throws:
    
    IOException - if a remote or network exception occurs.
  - getKeysAndRegionsInRange
```
private Pair<List<byte[]>,List<HRegionLocation>> getKeysAndRegionsInRange(byte[] startKey,
                                                                          byte[] endKey,
                                                                          boolean includeEndKey)
                                                                   throws IOException
```
    Get the corresponding start keys and regions for an arbitrary range of keys.
    
    Parameters:
    
    startKey - Starting row in range, inclusive
    
    endKey - Ending row in range
    
    includeEndKey - true if endRow is inclusive, false if exclusive
    
    Returns:
    
    A pair of list of start keys and list of HRegionLocations that contain the specified range
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - getKeysAndRegionsInRange
```
private Pair<List<byte[]>,List<HRegionLocation>> getKeysAndRegionsInRange(byte[] startKey,
                                                                          byte[] endKey,
                                                                          boolean includeEndKey,
                                                                          boolean reload)
                                                                   throws IOException
```
    Get the corresponding start keys and regions for an arbitrary range of keys.
    
    Parameters:
    
    startKey - Starting row in range, inclusive
    
    endKey - Ending row in range
    
    includeEndKey - true if endRow is inclusive, false if exclusive
    
    reload - true to reload information or false to use cached information
    
    Returns:
    
    A pair of list of start keys and list of HRegionLocations that contain the specified range
    
    Throws:
    
    IOException - if a remote or network exception occurs
  - getScanner
```
public ResultScanner getScanner(Scan scan)
                         throws IOException
```
    The underlying HTable must not be closed. Table.getScanner(Scan) has other usage details.
    
    Specified by:
    
    getScanner in interface Table
    
    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
```
    The underlying HTable must not be closed. Table.getScanner(byte[]) has other usage details.
    
    Specified by:
    
    getScanner in interface Table
    
    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
```
    The underlying HTable must not be closed. Table.getScanner(byte[], byte[]) has other usage details.
    
    Specified by:
    
    getScanner in interface Table
    
    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.
  - get
```
public Result get(Get get)
           throws IOException
```
    Description copied from interface: Table
    
    Extracts certain cells from a given row.
    
    Specified by:
    
    get in interface Table
    
    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
```
private Result get(Get get,
                   boolean checkExistenceOnly)
            throws IOException
```
    Throws:
    
    IOException
  - get
```
public Result[] get(List<Get> gets)
             throws IOException
```
    Description copied from interface: Table
    
    Extracts specified cells from the given rows, as a batch.
    
    Specified by:
    
    get in interface Table
    
    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 Cells, 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. The ordering of the Result array corresponds to the order of the list of passed in Gets.
    
    Throws:
    
    IOException - if a remote or network exception occurs.
  - batch
```
public void batch(List<? extends Row> actions,
                  Object[] results)
           throws InterruptedException,
                  IOException
```
    Description copied from interface: Table
    
    Method that does a batch call on Deletes, Gets, Puts, Increments, Appends, RowMutations. The ordering of execution of the actions is not defined. Meaning if you do a Put and a Get in the same Table.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.
    
    Specified by:
    
    batch in interface Table
    
    Parameters:
    
    actions - list of Get, Put, Delete, Increment, Append, RowMutations.
    
    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. The order of the objects in the results array corresponds to the order of actions in the request list. n * @since 0.90.0
    
    Throws:
    
    InterruptedException
    
    IOException
  - batch
```
public void batch(List<? extends Row> actions,
                  Object[] results,
                  int rpcTimeout)
           throws InterruptedException,
                  IOException
```
    Throws:
    
    InterruptedException
    
    IOException
  - batchCallback
```
public <R> void batchCallback(List<? extends Row> actions,
                              Object[] results,
                              Batch.Callback<R> callback)
                       throws IOException,
                              InterruptedException
```
    Description copied from interface: Table
    
    Same as Table.batch(List, Object[]), but with a callback.
    
    Specified by:
    
    batchCallback in interface Table
    
    Throws:
    
    IOException
    
    InterruptedException
  - doBatchWithCallback
```
public static <R> void doBatchWithCallback(List<? extends Row> actions,
                                           Object[] results,
                                           Batch.Callback<R> callback,
                                           ClusterConnection connection,
                                           ExecutorService pool,
                                           TableName tableName)
                                    throws InterruptedIOException,
                                           RetriesExhaustedWithDetailsException
```
    Throws:
    
    InterruptedIOException
    
    RetriesExhaustedWithDetailsException
  - delete
```
public void delete(Delete delete)
            throws IOException
```
    Description copied from interface: Table
    
    Deletes the specified cells/row.
    
    Specified by:
    
    delete in interface Table
    
    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: Table
    
    Batch Deletes the specified cells/rows from the table.
    If a specified row does not exist, Delete will report as though sucessful delete; no exception will be thrown. If there are any failures even after retries, a RetriesExhaustedWithDetailsException will be thrown. RetriesExhaustedWithDetailsException contains lists of failed Deletes and corresponding remote exceptions.
    
    Specified by:
    
    delete in interface Table
    
    Parameters:
    
    deletes - List of things to delete. The input list gets modified by this method. All successfully applied Deletes in the list are removed (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.
  - put
```
public void put(Put put)
         throws IOException
```
    Description copied from interface: Table
    
    Puts some data in the table.
    
    Specified by:
    
    put in interface Table
    
    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: Table
    
    Batch puts the specified data into the table.
    This can be used for group commit, or for submitting user defined batches. Before sending a batch of mutations to the server, the client runs a few validations on the input list. If an error is found, for example, a mutation was supplied but was missing it's column an IllegalArgumentException will be thrown and no mutations will be applied. If there are any failures even after retries, a RetriesExhaustedWithDetailsException will be thrown. RetriesExhaustedWithDetailsException contains lists of failed mutations and corresponding remote exceptions. The ordering of mutations and exceptions in the encapsulating exception corresponds to the order of the input list of Put requests.
    
    Specified by:
    
    put in interface Table
    
    Parameters:
    
    puts - The list of mutations to apply.
    
    Throws:
    
    IOException - if a remote or network exception occurs.
  - mutateRow
```
public Result mutateRow(RowMutations rm)
                 throws IOException
```
    Description copied from interface: Table
    
    Performs multiple mutations atomically on a single row. Currently Put and Delete are supported.
    
    Specified by:
    
    mutateRow in interface Table
    
    Parameters:
    
    rm - object that specifies the set of mutations to perform atomically
    
    Returns:
    
    results of Increment/Append operations
    
    Throws:
    
    IOException - if a remote or network exception occurs.
  - getNonceGroup
```
private long getNonceGroup()
```
  - getNonce
```
private long getNonce()
```
  - append
```
public Result append(Append append)
              throws IOException
```
    Description copied from interface: Table
    
    Appends values to one or more columns within a single row.
    This operation guaranteed atomicity to readers. Appends are done under a single row lock, so write operations to a row are synchronized, and readers are guaranteed to see this operation fully completed.
    
    Specified by:
    
    append in interface Table
    
    Parameters:
    
    append - object that specifies the columns and values to be appended
    
    Returns:
    
    values of columns after the append operation (maybe null)
    
    Throws:
    
    IOException - e
  - increment
```
public Result increment(Increment increment)
                 throws IOException
```
    Description copied from interface: Table
    
    Increments one or more columns within a single row.
    This operation ensures atomicity to readers. Increments are done under a single row lock, so write operations to a row are synchronized, and readers are guaranteed to see this operation fully completed.
    
    Specified by:
    
    increment in interface Table
    
    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
  - incrementColumnValue
```
public long incrementColumnValue(byte[] row,
                                 byte[] family,
                                 byte[] qualifier,
                                 long amount)
                          throws IOException
```
    Description copied from interface: Table
    
    See Table.incrementColumnValue(byte[], byte[], byte[], long, Durability)
    The Durability is defaulted to Durability.SYNC_WAL.
    
    Specified by:
    
    incrementColumnValue in interface Table
    
    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: Table
    
    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 Table
    
    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.
  - checkAndPut
```
@Deprecated
public boolean checkAndPut(byte[] row,
                                       byte[] family,
                                       byte[] qualifier,
                                       byte[] value,
                                       Put put)
                                throws IOException
```
    Deprecated.
    
    Description copied from interface: Table
    
    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 Table
    
    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
  - checkAndPut
```
@Deprecated
public boolean checkAndPut(byte[] row,
                                       byte[] family,
                                       byte[] qualifier,
                                       CompareFilter.CompareOp compareOp,
                                       byte[] value,
                                       Put put)
                                throws IOException
```
    Deprecated.
    
    Description copied from interface: Table
    
    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-existence) The expected value argument of this call is on the left and the current value of the cell is on the right side of the comparison operator. Ie. eg. GREATER operator means expected value > existing <=> add the put.
    
    Specified by:
    
    checkAndPut in interface Table
    
    Parameters:
    
    row - to check
    
    family - column family to check
    
    qualifier - column qualifier to check
    
    compareOp - comparison operator to use
    
    value - the expected value
    
    put - data to put if check succeeds
    
    Returns:
    
    true if the new put was executed, false otherwise
    
    Throws:
    
    IOException - e
  - checkAndPut
```
@Deprecated
public boolean checkAndPut(byte[] row,
                                       byte[] family,
                                       byte[] qualifier,
                                       CompareOperator op,
                                       byte[] value,
                                       Put put)
                                throws IOException
```
    Deprecated.
    
    Description copied from interface: Table
    
    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-existence) The expected value argument of this call is on the left and the current value of the cell is on the right side of the comparison operator. Ie. eg. GREATER operator means expected value > existing <=> add the put.
    
    Specified by:
    
    checkAndPut in interface Table
    
    Parameters:
    
    row - to check
    
    family - column family to check
    
    qualifier - column qualifier to check
    
    op - comparison operator to use
    
    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
```
@Deprecated
public boolean checkAndDelete(byte[] row,
                                          byte[] family,
                                          byte[] qualifier,
                                          byte[] value,
                                          Delete delete)
                                   throws IOException
```
    Deprecated.
    
    Description copied from interface: Table
    
    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 Table
    
    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
  - checkAndDelete
```
@Deprecated
public boolean checkAndDelete(byte[] row,
                                          byte[] family,
                                          byte[] qualifier,
                                          CompareFilter.CompareOp compareOp,
                                          byte[] value,
                                          Delete delete)
                                   throws IOException
```
    Deprecated.
    
    Description copied from interface: Table
    
    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-existence) The expected value argument of this call is on the left and the current value of the cell is on the right side of the comparison operator. Ie. eg. GREATER operator means expected value > existing <=> add the delete.
    
    Specified by:
    
    checkAndDelete in interface Table
    
    Parameters:
    
    row - to check
    
    family - column family to check
    
    qualifier - column qualifier to check
    
    compareOp - comparison operator to use
    
    value - the expected value
    
    delete - data to delete if check succeeds
    
    Returns:
    
    true if the new delete was executed, false otherwise
    
    Throws:
    
    IOException - e
  - checkAndDelete
```
@Deprecated
public boolean checkAndDelete(byte[] row,
                                          byte[] family,
                                          byte[] qualifier,
                                          CompareOperator op,
                                          byte[] value,
                                          Delete delete)
                                   throws IOException
```
    Deprecated.
    
    Description copied from interface: Table
    
    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-existence) The expected value argument of this call is on the left and the current value of the cell is on the right side of the comparison operator. Ie. eg. GREATER operator means expected value > existing <=> add the delete.
    
    Specified by:
    
    checkAndDelete in interface Table
    
    Parameters:
    
    row - to check
    
    family - column family to check
    
    qualifier - column qualifier to check
    
    op - comparison operator to use
    
    value - the expected value
    
    delete - data to delete if check succeeds
    
    Returns:
    
    true if the new delete was executed, false otherwise
    
    Throws:
    
    IOException - e
  - checkAndMutate
```
@Deprecated
public Table.CheckAndMutateBuilder checkAndMutate(byte[] row,
                                                              byte[] family)
```
    Deprecated.
    
    Description copied from interface: Table
    Atomically checks if a row/family/qualifier value matches the expected value. If it does, it adds the Put/Delete/RowMutations.
    Use the returned Table.CheckAndMutateBuilder to construct your request and then execute it. This is a fluent style API, the code is like:
```
 
 table.checkAndMutate(row, family).qualifier(qualifier).ifNotExists().thenPut(put);
 
 
```
    Specified by:
    
    checkAndMutate in interface Table
  - checkAndMutate
```
@Deprecated
public Table.CheckAndMutateWithFilterBuilder checkAndMutate(byte[] row,
                                                                        Filter filter)
```
    Deprecated.
    
    Description copied from interface: Table
    Atomically checks if a row matches the specified filter. If it does, it adds the Put/Delete/RowMutations.
    Use the returned Table.CheckAndMutateWithFilterBuilder to construct your request and then execute it. This is a fluent style API, the code is like:
```
 
 table.checkAndMutate(row, filter).thenPut(put);
 
 
```
    Specified by:
    
    checkAndMutate in interface Table
  - doCheckAndMutate
```
private CheckAndMutateResult doCheckAndMutate(byte[] row,
                                              byte[] family,
                                              byte[] qualifier,
                                              CompareOperator op,
                                              byte[] value,
                                              Filter filter,
                                              TimeRange timeRange,
                                              RowMutations rm)
                                       throws IOException
```
    Throws:
    
    IOException
  - checkAndMutate
```
@Deprecated
public boolean checkAndMutate(byte[] row,
                                          byte[] family,
                                          byte[] qualifier,
                                          CompareFilter.CompareOp compareOp,
                                          byte[] value,
                                          RowMutations rm)
                                   throws IOException
```
    Deprecated.
    
    Description copied from interface: Table
    
    Atomically checks if a row/family/qualifier value matches the expected value. If it does, it performs the row mutations. If the passed value is null, the check is for the lack of column (ie: non-existence) The expected value argument of this call is on the left and the current value of the cell is on the right side of the comparison operator. Ie. eg. GREATER operator means expected value > existing <=> perform row mutations.
    
    Specified by:
    
    checkAndMutate in interface Table
    
    Parameters:
    
    row - to check
    
    family - column family to check
    
    qualifier - column qualifier to check
    
    compareOp - the comparison operator
    
    value - the expected value
    
    rm - mutations to perform if check succeeds
    
    Returns:
    
    true if the new put was executed, false otherwise
    
    Throws:
    
    IOException - e
  - checkAndMutate
```
@Deprecated
public boolean checkAndMutate(byte[] row,
                                          byte[] family,
                                          byte[] qualifier,
                                          CompareOperator op,
                                          byte[] value,
                                          RowMutations rm)
                                   throws IOException
```
    Deprecated.
    
    Description copied from interface: Table
    
    Atomically checks if a row/family/qualifier value matches the expected value. If it does, it performs the row mutations. If the passed value is null, the check is for the lack of column (ie: non-existence) The expected value argument of this call is on the left and the current value of the cell is on the right side of the comparison operator. Ie. eg. GREATER operator means expected value > existing <=> perform row mutations.
    
    Specified by:
    
    checkAndMutate in interface Table
    
    Parameters:
    
    row - to check
    
    family - column family to check
    
    qualifier - column qualifier to check
    
    op - the comparison operator
    
    value - the expected value
    
    rm - mutations to perform if check succeeds
    
    Returns:
    
    true if the new put was executed, false otherwise
    
    Throws:
    
    IOException - e
  - checkAndMutate
```
public CheckAndMutateResult checkAndMutate(CheckAndMutate checkAndMutate)
                                    throws IOException
```
    Description copied from interface: Table
    
    checkAndMutate that atomically checks if a row matches the specified condition. If it does, it performs the specified action.
    
    Specified by:
    
    checkAndMutate in interface Table
    
    Parameters:
    
    checkAndMutate - The CheckAndMutate object.
    
    Returns:
    
    A CheckAndMutateResult object that represents the result for the CheckAndMutate.
    
    Throws:
    
    IOException - if a remote or network exception occurs.
  - doCheckAndMutate
```
private CheckAndMutateResult doCheckAndMutate(byte[] row,
                                              byte[] family,
                                              byte[] qualifier,
                                              CompareOperator op,
                                              byte[] value,
                                              Filter filter,
                                              TimeRange timeRange,
                                              Mutation mutation)
                                       throws IOException
```
    Throws:
    
    IOException
  - checkAndMutate
```
public List<CheckAndMutateResult> checkAndMutate(List<CheckAndMutate> checkAndMutates)
                                          throws IOException
```
    Description copied from interface: Table
    
    Batch version of checkAndMutate. The specified CheckAndMutates are batched only in the sense that they are sent to a RS in one RPC, but each CheckAndMutate operation is still executed atomically (and thus, each may fail independently of others).
    
    Specified by:
    
    checkAndMutate in interface Table
    
    Parameters:
    
    checkAndMutates - The list of CheckAndMutate.
    
    Returns:
    
    A list of CheckAndMutateResult objects that represents the result for each CheckAndMutate.
    
    Throws:
    
    IOException - if a remote or network exception occurs.
  - toCompareOperator
```
private CompareOperator toCompareOperator(CompareFilter.CompareOp compareOp)
```
  - exists
```
public boolean exists(Get get)
               throws IOException
```
    Description copied from interface: Table
    
    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 Table
    
    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
```
    Description copied from interface: Table
    
    Test for the existence of columns in the table, as specified by the Gets.
    This will return an array of booleans. Each value will be true if the related Get matches one or more keys, false if not.
    This is a server-side call so it prevents any data from being transferred to the client.
    
    Specified by:
    
    exists in interface Table
    
    Parameters:
    
    gets - the Gets
    
    Returns:
    
    Array of boolean. True if the specified Get matches one or more keys, false if not.
    
    Throws:
    
    IOException - e
  - processBatchCallback
```
public <R> void processBatchCallback(List<? extends Row> list,
                                     Object[] results,
                                     Batch.Callback<R> callback)
                              throws IOException,
                                     InterruptedException
```
    Process a mixed batch of Get, Put and Delete actions. All actions for a RegionServer are forwarded in one RPC call. Queries are executed in parallel.
    
    Parameters:
    
    list - The collection of actions.
    
    results - An empty array, same size as list. If an exception is thrown, you can test here for partial results, and to determine which actions processed successfully.
    
    Throws:
    
    IOException - if there are problems talking to META. Per-item exceptions are stored in the results array.
    
    InterruptedException
  - close
```
public void close()
           throws IOException
```
    Description copied from interface: Table
    
    Releases any resources held or pending changes in internal buffers.
    
    Specified by:
    
    close in interface Closeable
    
    Specified by:
    
    close in interface AutoCloseable
    
    Specified by:
    
    close in interface Table
    
    Throws:
    
    IOException - if a remote or network exception occurs.
  - validatePut
```
private void validatePut(Put put)
                  throws IllegalArgumentException
```
    Throws:
    
    IllegalArgumentException
  - getPool
```
ExecutorService getPool()
```
    The pool is used for mutli requests for this HTable
    
    Returns:
    
    the pool used for mutli
  - clearRegionCache
```
public void clearRegionCache()
```
    Explicitly clears the region cache to fetch the latest value from META. This is a power user function: avoid unless you know the ramifications.
  - coprocessorService
```
public CoprocessorRpcChannel coprocessorService(byte[] row)
```
    Description copied from interface: Table
    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 Table
    
    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: Table
    
    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 Table
    
    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: Table
    
    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 Table
    
    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
  - getStartKeysInRange
```
private List<byte[]> getStartKeysInRange(byte[] start,
                                         byte[] end)
                                  throws IOException
```
    Throws:
    
    IOException
  - getRpcTimeout
```
public long getRpcTimeout(TimeUnit unit)
```
    Description copied from interface: Table
    
    Get timeout of each rpc request in this Table instance. It will be overridden by a more specific rpc timeout config such as readRpcTimeout or writeRpcTimeout.
    
    Specified by:
    
    getRpcTimeout in interface Table
    
    Parameters:
    
    unit - the unit of time the timeout to be represented in
    
    Returns:
    
    rpc timeout in the specified time unit
    
    See Also:
    
    Table.getReadRpcTimeout(TimeUnit), Table.getWriteRpcTimeout(TimeUnit)
  - getRpcTimeout
```
@Deprecated
public int getRpcTimeout()
```
    Deprecated.
    
    Description copied from interface: Table
    
    Get timeout (millisecond) of each rpc request in this Table instance.
    
    Specified by:
    
    getRpcTimeout in interface Table
    
    Returns:
    
    Currently configured read timeout
  - setRpcTimeout
```
@Deprecated
public void setRpcTimeout(int rpcTimeout)
```
    Deprecated.
    
    Description copied from interface: Table
    
    Set timeout (millisecond) of each rpc request in operations of this Table instance, will override the value of hbase.rpc.timeout in configuration. If a rpc request waiting too long, it will stop waiting and send a new request to retry until retries exhausted or operation timeout reached.
    NOTE: This will set both the read and write timeout settings to the provided value.
    
    Specified by:
    
    setRpcTimeout in interface Table
    
    Parameters:
    
    rpcTimeout - the timeout of each rpc request in millisecond.
  - getReadRpcTimeout
```
public long getReadRpcTimeout(TimeUnit unit)
```
    Description copied from interface: Table
    
    Get timeout of each rpc read request in this Table instance.
    
    Specified by:
    
    getReadRpcTimeout in interface Table
    
    Parameters:
    
    unit - the unit of time the timeout to be represented in
    
    Returns:
    
    read rpc timeout in the specified time unit
  - getReadRpcTimeout
```
@Deprecated
public int getReadRpcTimeout()
```
    Deprecated.
    
    Description copied from interface: Table
    
    Get timeout (millisecond) of each rpc read request in this Table instance.
    
    Specified by:
    
    getReadRpcTimeout in interface Table
  - setReadRpcTimeout
```
@Deprecated
public void setReadRpcTimeout(int readRpcTimeout)
```
    Deprecated.
    
    Description copied from interface: Table
    
    Set timeout (millisecond) of each rpc read request in operations of this Table instance, will override the value of hbase.rpc.read.timeout in configuration. If a rpc read request waiting too long, it will stop waiting and send a new request to retry until retries exhausted or operation timeout reached.
    
    Specified by:
    
    setReadRpcTimeout in interface Table
    
    Parameters:
    
    readRpcTimeout - the timeout for read rpc request in milliseconds
  - getWriteRpcTimeout
```
public long getWriteRpcTimeout(TimeUnit unit)
```
    Description copied from interface: Table
    
    Get timeout of each rpc write request in this Table instance.
    
    Specified by:
    
    getWriteRpcTimeout in interface Table
    
    Parameters:
    
    unit - the unit of time the timeout to be represented in
    
    Returns:
    
    write rpc timeout in the specified time unit
  - getWriteRpcTimeout
```
@Deprecated
public int getWriteRpcTimeout()
```
    Deprecated.
    
    Description copied from interface: Table
    
    Get timeout (millisecond) of each rpc write request in this Table instance.
    
    Specified by:
    
    getWriteRpcTimeout in interface Table
  - setWriteRpcTimeout
```
@Deprecated
public void setWriteRpcTimeout(int writeRpcTimeout)
```
    Deprecated.
    
    Description copied from interface: Table
    
    Set timeout (millisecond) of each rpc write request in operations of this Table instance, will override the value of hbase.rpc.write.timeout in configuration. If a rpc write request waiting too long, it will stop waiting and send a new request to retry until retries exhausted or operation timeout reached.
    
    Specified by:
    
    setWriteRpcTimeout in interface Table
    
    Parameters:
    
    writeRpcTimeout - the timeout for write rpc request in milliseconds
  - getOperationTimeout
```
public long getOperationTimeout(TimeUnit unit)
```
    Description copied from interface: Table
    
    Get timeout of each operation in Table instance.
    
    Specified by:
    
    getOperationTimeout in interface Table
    
    Parameters:
    
    unit - the unit of time the timeout to be represented in
    
    Returns:
    
    operation rpc timeout in the specified time unit
  - getOperationTimeout
```
@Deprecated
public int getOperationTimeout()
```
    Deprecated.
    
    Description copied from interface: Table
    
    Get timeout (millisecond) of each operation for in Table instance.
    
    Specified by:
    
    getOperationTimeout in interface Table
  - setOperationTimeout
```
@Deprecated
public void setOperationTimeout(int operationTimeout)
```
    Deprecated.
    
    Description copied from interface: Table
    
    Set timeout (millisecond) of each operation in this Table instance, will override the value of hbase.client.operation.timeout in configuration. Operation timeout is a top-level restriction that makes sure a blocking method will not be blocked more than this. In each operation, if rpc request fails because of timeout or other reason, it will retry until success or throw a RetriesExhaustedException. But if the total time being blocking reach the operation timeout before retries exhausted, it will break early and throw SocketTimeoutException.
    
    Specified by:
    
    setOperationTimeout in interface Table
    
    Parameters:
    
    operationTimeout - the total timeout of each operation in millisecond.
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - batchCoprocessorService
```
public <R extends com.google.protobuf.Message> Map<byte[],R> batchCoprocessorService(com.google.protobuf.Descriptors.MethodDescriptor methodDescriptor,
                                                                                     com.google.protobuf.Message request,
                                                                                     byte[] startKey,
                                                                                     byte[] endKey,
                                                                                     R responsePrototype)
                                                                              throws com.google.protobuf.ServiceException,
                                                                                     Throwable
```
    Description copied from interface: Table
    
    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. The coprocessor service is invoked according to the service instance, method name and parameters. n * the descriptor for the protobuf service method to call. n * the method call parameters n * start region selection with region containing this row. If null, the selection will start with the first table region. n * select regions up to and including the region containing this row. If null, selection will continue through the last table region. n * the proto type of the response of the method in Service.
    
    Specified by:
    
    batchCoprocessorService in interface Table
    
    Type Parameters:
    
    R - the response type for the coprocessor Service method
    
    Returns:
    
    a map of result values keyed by region name
    
    Throws:
    
    com.google.protobuf.ServiceException
    
    Throwable
  - batchCoprocessorService
```
public <R extends com.google.protobuf.Message> void batchCoprocessorService(com.google.protobuf.Descriptors.MethodDescriptor methodDescriptor,
                                                                            com.google.protobuf.Message request,
                                                                            byte[] startKey,
                                                                            byte[] endKey,
                                                                            R responsePrototype,
                                                                            Batch.Callback<R> callback)
                                                                     throws com.google.protobuf.ServiceException,
                                                                            Throwable
```
    Description copied from interface: Table
    
    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. 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.
    
    Specified by:
    
    batchCoprocessorService in interface Table
    
    Type Parameters:
    
    R - the response type for the coprocessor Service method
    
    Parameters:
    
    methodDescriptor - the descriptor for the protobuf service method to call.
    
    request - the method call parameters
    
    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.
    
    responsePrototype - the proto type of the response of the method in Service.
    
    callback - callback to invoke with the response for each region
    
    Throws:
    
    com.google.protobuf.ServiceException
    
    Throwable
  - getRegionLocator
```
public RegionLocator getRegionLocator()
```
    Description copied from interface: Table
    
    Gets the RegionLocator for this table.
    
    Specified by:
    
    getRegionLocator in interface Table

Class HTable

Nested Class Summary

Nested classes/interfaces inherited from interface org.apache.hadoop.hbase.client.Table

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface org.apache.hadoop.hbase.client.Table

Field Detail

LOG

DEFAULT_CONSISTENCY

connection

tableName

configuration

connConfiguration

closed

scannerCaching

scannerMaxResultSize

pool

operationTimeoutMs

rpcTimeoutMs

readRpcTimeoutMs

writeRpcTimeoutMs

scanReadRpcTimeout

scanTimeout

cleanupPoolOnClose

locator

multiAp

rpcCallerFactory

rpcControllerFactory

Constructor Detail

HTable

Method Detail

getDefaultExecutor

getMaxKeyValueSize

getConfiguration

getName

getConnection

getTableDescriptor

getDescriptor

getKeysAndRegionsInRange

getKeysAndRegionsInRange

getScanner

getScanner

getScanner

get

get

get

batch

batch

batchCallback

doBatchWithCallback

delete

delete

put

put

mutateRow

getNonceGroup

getNonce

append

increment

incrementColumnValue

incrementColumnValue

checkAndPut

checkAndPut

checkAndPut

checkAndDelete

checkAndDelete

checkAndDelete

checkAndMutate

checkAndMutate

doCheckAndMutate

checkAndMutate

checkAndMutate

checkAndMutate

doCheckAndMutate

checkAndMutate

toCompareOperator

exists

exists