RawAsyncTableImpl (Apache HBase 2.5.0 API)

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

All Implemented Interfaces:

AsyncTable<AdvancedScanResultConsumer>
```
@InterfaceAudience.Private
class RawAsyncTableImpl
extends Object
implements AsyncTable<AdvancedScanResultConsumer>
```
The implementation of RawAsyncTable.
The word 'Raw' means that this is a low level class. The returned CompletableFuture will be finished inside the rpc framework thread, which means that the callbacks registered to the CompletableFuture will also be executed inside the rpc framework thread. So users who use this class should not try to do time consuming tasks in the callbacks.

Since:

2.0.0

See Also:

AsyncTableImpl

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`private class`	`RawAsyncTableImpl.CheckAndMutateBuilderImpl`
`private class`	`RawAsyncTableImpl.CheckAndMutateWithFilterBuilderImpl`
`private static interface`	`RawAsyncTableImpl.Converter<D,I,S>`
`private class`	`RawAsyncTableImpl.CoprocessorServiceBuilderImpl<S,R>`
`private static interface`	`RawAsyncTableImpl.NoncedConverter<D,I,S>`
`private static interface`	`RawAsyncTableImpl.RpcCall<RESP,REQ>`

Nested classes/interfaces inherited from interface org.apache.hadoop.hbase.client.AsyncTable
AsyncTable.CheckAndMutateBuilder, AsyncTable.CheckAndMutateWithFilterBuilder, AsyncTable.CoprocessorCallback<R>, AsyncTable.CoprocessorServiceBuilder<S,R>

Field Summary

Fields
Modifier and Type	Field and Description
`private AsyncConnectionImpl`	`conn`
`private int`	`defaultScannerCaching`
`private long`	`defaultScannerMaxResultSize`
`private static org.slf4j.Logger`	`LOG`
`private int`	`maxAttempts`
`private long`	`operationTimeoutNs`
`private long`	`pauseNs`
`private long`	`pauseNsForServerOverloaded`
`private long`	`readRpcTimeoutNs`
`private org.apache.hbase.thirdparty.io.netty.util.Timer`	`retryTimer`
`private long`	`rpcTimeoutNs`
`private long`	`scanTimeoutNs`
`private int`	`startLogErrorsCnt`
`private TableName`	`tableName`
`private long`	`writeRpcTimeoutNs`

Constructor Summary

Constructors
Constructor and Description
`RawAsyncTableImpl(AsyncConnectionImpl conn, org.apache.hbase.thirdparty.io.netty.util.Timer retryTimer, AsyncTableBuilderBase<?> builder)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`CompletableFuture<Result>`	`append(Append append)` Appends values to one or more columns within a single row.
`<T> List<CompletableFuture<T>>`	`batch(List<? extends Row> actions)` Method that does a batch call on Deletes, Gets, Puts, Increments, Appends and RowMutations.
`private <T> List<CompletableFuture<T>>`	`batch(List<? extends Row> actions, long rpcTimeoutNs)`
`private static <REQ,PREQ,PRESP,RESP> CompletableFuture<RESP>`	`call(HBaseRpcController controller, HRegionLocation loc, org.apache.hadoop.hbase.shaded.protobuf.generated.ClientProtos.ClientService.Interface stub, REQ req, RawAsyncTableImpl.Converter<PREQ,byte[],REQ> reqConvert, RawAsyncTableImpl.RpcCall<PRESP,PREQ> rpcCall, RawAsyncTableImpl.Converter<RESP,HBaseRpcController,PRESP> respConverter)`
`AsyncTable.CheckAndMutateBuilder`	`checkAndMutate(byte[] row, byte[] family)` Atomically checks if a row/family/qualifier value matches the expected value.
`AsyncTable.CheckAndMutateWithFilterBuilder`	`checkAndMutate(byte[] row, Filter filter)` Atomically checks if a row matches the specified filter.
`CompletableFuture<CheckAndMutateResult>`	`checkAndMutate(CheckAndMutate checkAndMutate)` checkAndMutate that atomically checks if a row matches the specified condition.
`List<CompletableFuture<CheckAndMutateResult>>`	`checkAndMutate(List<CheckAndMutate> checkAndMutates)` Batch version of checkAndMutate.
`<S,R> AsyncTable.CoprocessorServiceBuilder<S,R>`	`coprocessorService(Function<com.google.protobuf.RpcChannel,S> stubMaker, ServiceCaller<S,R> callable, AsyncTable.CoprocessorCallback<R> callback)` Execute a coprocessor call on the regions which are covered by a range.
`<S,R> CompletableFuture<R>`	`coprocessorService(Function<com.google.protobuf.RpcChannel,S> stubMaker, ServiceCaller<S,R> callable, byte[] row)` Execute the given coprocessor call on the region which contains the given `row`.
`private <S,R> CompletableFuture<R>`	`coprocessorService(Function<com.google.protobuf.RpcChannel,S> stubMaker, ServiceCaller<S,R> callable, RegionInfo region, byte[] row)`
`CompletableFuture<Void>`	`delete(Delete delete)` Deletes the specified cells/row.
`List<CompletableFuture<Void>>`	`delete(List<Delete> deletes)` Deletes the specified cells/rows in bulk.
`CompletableFuture<Result>`	`get(Get get)` Extracts certain cells from a given row.
`private CompletableFuture<Result>`	`get(Get get, int replicaId)`
`List<CompletableFuture<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.
`CompletableFuture<TableDescriptor>`	`getDescriptor()` Gets the `TableDescriptor` for this table.
`TableName`	`getName()` Gets the fully qualified table name instance of this table.
`long`	`getOperationTimeout(TimeUnit unit)` Get timeout of each operation in Table instance.
`long`	`getReadRpcTimeout(TimeUnit unit)` Get timeout of each rpc read request in this Table instance.
`AsyncTableRegionLocator`	`getRegionLocator()` Gets the `AsyncTableRegionLocator` for this table.
`long`	`getRpcTimeout(TimeUnit unit)` Get timeout of each rpc request in this Table instance.
`AsyncTableResultScanner`	`getScanner(Scan scan)` Returns a scanner on the current table as specified by the `Scan` object.
`long`	`getScanTimeout(TimeUnit unit)` Get the timeout of a single operation in a scan.
`long`	`getWriteRpcTimeout(TimeUnit unit)` Get timeout of each rpc write request in this Table instance.
`CompletableFuture<Result>`	`increment(Increment increment)` Increments one or more columns within a single row.
`private boolean`	`locateFinished(RegionInfo region, byte[] endKey, boolean endKeyInclusive)`
`private static <REQ,RESP> CompletableFuture<RESP>`	`mutate(HBaseRpcController controller, HRegionLocation loc, org.apache.hadoop.hbase.shaded.protobuf.generated.ClientProtos.ClientService.Interface stub, REQ req, RawAsyncTableImpl.Converter<org.apache.hadoop.hbase.shaded.protobuf.generated.ClientProtos.MutateRequest,byte[],REQ> reqConvert, RawAsyncTableImpl.Converter<RESP,HBaseRpcController,org.apache.hadoop.hbase.shaded.protobuf.generated.ClientProtos.MutateResponse> respConverter)`
`private <RES,RESP> CompletableFuture<RESP>`	`mutateRow(HBaseRpcController controller, HRegionLocation loc, org.apache.hadoop.hbase.shaded.protobuf.generated.ClientProtos.ClientService.Interface stub, RowMutations mutation, RawAsyncTableImpl.Converter<org.apache.hadoop.hbase.shaded.protobuf.generated.ClientProtos.MultiRequest,byte[],RowMutations> reqConvert, Function<RES,RESP> respConverter)`
`CompletableFuture<Result>`	`mutateRow(RowMutations mutations)` Performs multiple mutations atomically on a single row.
`private <T> AsyncRpcRetryingCallerFactory.SingleRequestCallerBuilder<T>`	`newCaller(byte[] row, int priority, long rpcTimeoutNs)`
`private <T,R extends OperationWithAttributes & Row> AsyncRpcRetryingCallerFactory.SingleRequestCallerBuilder<T>`	`newCaller(R row, long rpcTimeoutNs)`
`private TableOperationSpanBuilder`	`newTableOperationSpanBuilder()`
`private <REQ,RESP> CompletableFuture<RESP>`	`noncedMutate(long nonceGroup, long nonce, HBaseRpcController controller, HRegionLocation loc, org.apache.hadoop.hbase.shaded.protobuf.generated.ClientProtos.ClientService.Interface stub, REQ req, RawAsyncTableImpl.NoncedConverter<org.apache.hadoop.hbase.shaded.protobuf.generated.ClientProtos.MutateRequest,byte[],REQ> reqConvert, RawAsyncTableImpl.Converter<RESP,HBaseRpcController,org.apache.hadoop.hbase.shaded.protobuf.generated.ClientProtos.MutateResponse> respConverter)`
`private <S,R> void`	`onLocateComplete(Function<com.google.protobuf.RpcChannel,S> stubMaker, ServiceCaller<S,R> callable, AsyncTable.CoprocessorCallback<R> callback, List<HRegionLocation> locs, byte[] endKey, boolean endKeyInclusive, AtomicBoolean locateFinished, AtomicInteger unfinishedRequest, HRegionLocation loc, Throwable error)`
`List<CompletableFuture<Void>>`	`put(List<Put> puts)` Puts some data in the table, in batch.
`CompletableFuture<Void>`	`put(Put put)` Puts some data to the table.
`private long`	`resultSize2CacheSize(long maxResultSize)`
`void`	`scan(Scan scan, AdvancedScanResultConsumer consumer)` The scan API uses the observer pattern.
`CompletableFuture<List<Result>>`	`scanAll(Scan scan)` Return all the results that match the given scan object.
`private Scan`	`setDefaultScanConfig(Scan scan)`
`private static Result`	`toResult(HBaseRpcController controller, org.apache.hadoop.hbase.shaded.protobuf.generated.ClientProtos.MutateResponse resp)`
`private static <REQ> CompletableFuture<Void>`	`voidMutate(HBaseRpcController controller, HRegionLocation loc, org.apache.hadoop.hbase.shaded.protobuf.generated.ClientProtos.ClientService.Interface stub, REQ req, RawAsyncTableImpl.Converter<org.apache.hadoop.hbase.shaded.protobuf.generated.ClientProtos.MutateRequest,byte[],REQ> reqConvert)`
`private List<CompletableFuture<Void>>`	`voidMutate(List<? extends Row> actions)`

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

Methods inherited from interface org.apache.hadoop.hbase.client.AsyncTable
batchAll, checkAndMutateAll, deleteAll, exists, exists, existsAll, getAll, getScanner, getScanner, incrementColumnValue, incrementColumnValue, putAll

- Field Detail
  - LOG
```
private static final org.slf4j.Logger LOG
```
  - conn
```
private final AsyncConnectionImpl conn
```
  - retryTimer
```
private final org.apache.hbase.thirdparty.io.netty.util.Timer retryTimer
```
  - tableName
```
private final TableName tableName
```
  - defaultScannerCaching
```
private final int defaultScannerCaching
```
  - defaultScannerMaxResultSize
```
private final long defaultScannerMaxResultSize
```
  - rpcTimeoutNs
```
private final long rpcTimeoutNs
```
  - readRpcTimeoutNs
```
private final long readRpcTimeoutNs
```
  - writeRpcTimeoutNs
```
private final long writeRpcTimeoutNs
```
  - operationTimeoutNs
```
private final long operationTimeoutNs
```
  - scanTimeoutNs
```
private final long scanTimeoutNs
```
  - pauseNs
```
private final long pauseNs
```
  - pauseNsForServerOverloaded
```
private final long pauseNsForServerOverloaded
```
  - maxAttempts
```
private final int maxAttempts
```
  - startLogErrorsCnt
```
private final int startLogErrorsCnt
```
- Constructor Detail
  - RawAsyncTableImpl
```
RawAsyncTableImpl(AsyncConnectionImpl conn,
                  org.apache.hbase.thirdparty.io.netty.util.Timer retryTimer,
                  AsyncTableBuilderBase<?> builder)
```
- Method Detail
  - getName
```
public TableName getName()
```
    Description copied from interface: AsyncTable
    
    Gets the fully qualified table name instance of this table.
    
    Specified by:
    
    getName in interface AsyncTable<AdvancedScanResultConsumer>
  - getConfiguration
```
public org.apache.hadoop.conf.Configuration getConfiguration()
```
    Description copied from interface: AsyncTable
    
    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 AsyncTable<AdvancedScanResultConsumer>
  - getDescriptor
```
public CompletableFuture<TableDescriptor> getDescriptor()
```
    Description copied from interface: AsyncTable
    
    Gets the TableDescriptor for this table.
    
    Specified by:
    
    getDescriptor in interface AsyncTable<AdvancedScanResultConsumer>
  - getRegionLocator
```
public AsyncTableRegionLocator getRegionLocator()
```
    Description copied from interface: AsyncTable
    
    Gets the AsyncTableRegionLocator for this table.
    
    Specified by:
    
    getRegionLocator in interface AsyncTable<AdvancedScanResultConsumer>
  - call
```
private static <REQ,PREQ,PRESP,RESP> CompletableFuture<RESP> call(HBaseRpcController controller,
                                                                  HRegionLocation loc,
                                                                  org.apache.hadoop.hbase.shaded.protobuf.generated.ClientProtos.ClientService.Interface stub,
                                                                  REQ req,
                                                                  RawAsyncTableImpl.Converter<PREQ,byte[],REQ> reqConvert,
                                                                  RawAsyncTableImpl.RpcCall<PRESP,PREQ> rpcCall,
                                                                  RawAsyncTableImpl.Converter<RESP,HBaseRpcController,PRESP> respConverter)
```
  - mutate
```
private static <REQ,RESP> CompletableFuture<RESP> mutate(HBaseRpcController controller,
                                                         HRegionLocation loc,
                                                         org.apache.hadoop.hbase.shaded.protobuf.generated.ClientProtos.ClientService.Interface stub,
                                                         REQ req,
                                                         RawAsyncTableImpl.Converter<org.apache.hadoop.hbase.shaded.protobuf.generated.ClientProtos.MutateRequest,byte[],REQ> reqConvert,
                                                         RawAsyncTableImpl.Converter<RESP,HBaseRpcController,org.apache.hadoop.hbase.shaded.protobuf.generated.ClientProtos.MutateResponse> respConverter)
```
  - voidMutate
```
private static <REQ> CompletableFuture<Void> voidMutate(HBaseRpcController controller,
                                                        HRegionLocation loc,
                                                        org.apache.hadoop.hbase.shaded.protobuf.generated.ClientProtos.ClientService.Interface stub,
                                                        REQ req,
                                                        RawAsyncTableImpl.Converter<org.apache.hadoop.hbase.shaded.protobuf.generated.ClientProtos.MutateRequest,byte[],REQ> reqConvert)
```
  - toResult
```
private static Result toResult(HBaseRpcController controller,
                               org.apache.hadoop.hbase.shaded.protobuf.generated.ClientProtos.MutateResponse resp)
                        throws IOException
```
    Throws:
    
    IOException
  - noncedMutate
```
private <REQ,RESP> CompletableFuture<RESP> noncedMutate(long nonceGroup,
                                                        long nonce,
                                                        HBaseRpcController controller,
                                                        HRegionLocation loc,
                                                        org.apache.hadoop.hbase.shaded.protobuf.generated.ClientProtos.ClientService.Interface stub,
                                                        REQ req,
                                                        RawAsyncTableImpl.NoncedConverter<org.apache.hadoop.hbase.shaded.protobuf.generated.ClientProtos.MutateRequest,byte[],REQ> reqConvert,
                                                        RawAsyncTableImpl.Converter<RESP,HBaseRpcController,org.apache.hadoop.hbase.shaded.protobuf.generated.ClientProtos.MutateResponse> respConverter)
```
  - newCaller
```
private <T> AsyncRpcRetryingCallerFactory.SingleRequestCallerBuilder<T> newCaller(byte[] row,
                                                                                  int priority,
                                                                                  long rpcTimeoutNs)
```
  - newCaller
```
private <T,R extends OperationWithAttributes & Row> AsyncRpcRetryingCallerFactory.SingleRequestCallerBuilder<T> newCaller(R row,
                                                                                                                          long rpcTimeoutNs)
```
  - get
```
private CompletableFuture<Result> get(Get get,
                                      int replicaId)
```
  - newTableOperationSpanBuilder
```
private TableOperationSpanBuilder newTableOperationSpanBuilder()
```
  - get
```
public CompletableFuture<Result> get(Get get)
```
    Description copied from interface: AsyncTable
    
    Extracts certain cells from a given row.
    
    Specified by:
    
    get in interface AsyncTable<AdvancedScanResultConsumer>
    
    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(). The return value will be wrapped by a CompletableFuture.
  - put
```
public CompletableFuture<Void> put(Put put)
```
    Description copied from interface: AsyncTable
    
    Puts some data to the table.
    
    Specified by:
    
    put in interface AsyncTable<AdvancedScanResultConsumer>
    
    Parameters:
    
    put - The data to put.
    
    Returns:
    
    A CompletableFuture that always returns null when complete normally.
  - delete
```
public CompletableFuture<Void> delete(Delete delete)
```
    Description copied from interface: AsyncTable
    
    Deletes the specified cells/row.
    
    Specified by:
    
    delete in interface AsyncTable<AdvancedScanResultConsumer>
    
    Parameters:
    
    delete - The object that specifies what to delete.
    
    Returns:
    
    A CompletableFuture that always returns null when complete normally.
  - append
```
public CompletableFuture<Result> append(Append append)
```
    Description copied from interface: AsyncTable
    
    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 AsyncTable<AdvancedScanResultConsumer>
    
    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). The return value will be wrapped by a CompletableFuture.
  - increment
```
public CompletableFuture<Result> increment(Increment increment)
```
    Description copied from interface: AsyncTable
    
    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 AsyncTable<AdvancedScanResultConsumer>
    
    Parameters:
    
    increment - object that specifies the columns and amounts to be used for the increment operations
    
    Returns:
    
    values of columns after the increment. The return value will be wrapped by a CompletableFuture.
  - checkAndMutate
```
public AsyncTable.CheckAndMutateBuilder checkAndMutate(byte[] row,
                                                       byte[] family)
```
    Description copied from interface: AsyncTable
    Atomically checks if a row/family/qualifier value matches the expected value. If it does, it adds the Put/Delete/RowMutations.
    Use the returned AsyncTable.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)
   .thenAccept(succ -> {
     if (succ) {
       System.out.println("Check and put succeeded");
     } else {
       System.out.println("Check and put failed");
     }
   });
 
```
    Specified by:
    
    checkAndMutate in interface AsyncTable<AdvancedScanResultConsumer>
  - checkAndMutate
```
public AsyncTable.CheckAndMutateWithFilterBuilder checkAndMutate(byte[] row,
                                                                 Filter filter)
```
    Description copied from interface: AsyncTable
    Atomically checks if a row matches the specified filter. If it does, it adds the Put/Delete/RowMutations.
    Use the returned AsyncTable.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).thenAccept(succ -> {
   if (succ) {
     System.out.println("Check and put succeeded");
   } else {
     System.out.println("Check and put failed");
   }
 });
 
```
    Specified by:
    
    checkAndMutate in interface AsyncTable<AdvancedScanResultConsumer>
  - checkAndMutate
```
public CompletableFuture<CheckAndMutateResult> checkAndMutate(CheckAndMutate checkAndMutate)
```
    Description copied from interface: AsyncTable
    
    checkAndMutate that atomically checks if a row matches the specified condition. If it does, it performs the specified action.
    
    Specified by:
    
    checkAndMutate in interface AsyncTable<AdvancedScanResultConsumer>
    
    Parameters:
    
    checkAndMutate - The CheckAndMutate object.
    
    Returns:
    
    A CompletableFutures that represent the result for the CheckAndMutate.
  - checkAndMutate
```
public List<CompletableFuture<CheckAndMutateResult>> checkAndMutate(List<CheckAndMutate> checkAndMutates)
```
    Description copied from interface: AsyncTable
    
    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 AsyncTable<AdvancedScanResultConsumer>
    
    Parameters:
    
    checkAndMutates - The list of CheckAndMutate.
    
    Returns:
    
    A list of CompletableFutures that represent the result for each CheckAndMutate.
  - mutateRow
```
private <RES,RESP> CompletableFuture<RESP> mutateRow(HBaseRpcController controller,
                                                     HRegionLocation loc,
                                                     org.apache.hadoop.hbase.shaded.protobuf.generated.ClientProtos.ClientService.Interface stub,
                                                     RowMutations mutation,
                                                     RawAsyncTableImpl.Converter<org.apache.hadoop.hbase.shaded.protobuf.generated.ClientProtos.MultiRequest,byte[],RowMutations> reqConvert,
                                                     Function<RES,RESP> respConverter)
```
  - mutateRow
```
public CompletableFuture<Result> mutateRow(RowMutations mutations)
```
    Description copied from interface: AsyncTable
    
    Performs multiple mutations atomically on a single row. Currently Put and Delete are supported.
    
    Specified by:
    
    mutateRow in interface AsyncTable<AdvancedScanResultConsumer>
    
    Parameters:
    
    mutations - object that specifies the set of mutations to perform atomically
    
    Returns:
    
    A CompletableFuture that returns results of Increment/Append operations
  - setDefaultScanConfig
```
private Scan setDefaultScanConfig(Scan scan)
```
  - scan
```
public void scan(Scan scan,
                 AdvancedScanResultConsumer consumer)
```
    Description copied from interface: AsyncTable
    
    The scan API uses the observer pattern.
    
    Specified by:
    
    scan in interface AsyncTable<AdvancedScanResultConsumer>
    
    Parameters:
    
    scan - A configured Scan object.
    
    consumer - the consumer used to receive results.
    
    See Also:
    
    ScanResultConsumer, AdvancedScanResultConsumer
  - resultSize2CacheSize
```
private long resultSize2CacheSize(long maxResultSize)
```
  - getScanner
```
public AsyncTableResultScanner getScanner(Scan scan)
```
    Description copied from interface: AsyncTable
    
    Returns a scanner on the current table as specified by the Scan object.
    
    Specified by:
    
    getScanner in interface AsyncTable<AdvancedScanResultConsumer>
    
    Parameters:
    
    scan - A configured Scan object.
    
    Returns:
    
    A scanner.
  - scanAll
```
public CompletableFuture<List<Result>> scanAll(Scan scan)
```
    Description copied from interface: AsyncTable
    Return all the results that match the given scan object.
    Notice that usually you should use this method with a Scan object that has limit set. For example, if you want to get the closest row after a given row, you could do this:
```
 table.scanAll(new Scan().withStartRow(row, false).setLimit(1)).thenAccept(results -> {
   if (results.isEmpty()) {
     System.out.println("No row after " + Bytes.toStringBinary(row));
   } else {
     System.out.println("The closest row after " + Bytes.toStringBinary(row) + " is "
       + Bytes.toStringBinary(results.stream().findFirst().get().getRow()));
   }
 });
 
```
    If your result set is very large, you should use other scan method to get a scanner or use callback to process the results. They will do chunking to prevent OOM. The scanAll method will fetch all the results and store them in a List and then return the list to you.
    The scan metrics will be collected background if you enable it but you have no way to get it. Usually you can get scan metrics from ResultScanner, or through ScanResultConsumer.onScanMetricsCreated but this method only returns a list of results. So if you really care about scan metrics then you'd better use other scan methods which return a ResultScanner or let you pass in a ScanResultConsumer. There is no performance difference between these scan methods so do not worry.
    Specified by:
    
    scanAll in interface AsyncTable<AdvancedScanResultConsumer>
    
    Parameters:
    
    scan - A configured Scan object. So if you use this method to fetch a really large result set, it is likely to cause OOM.
    
    Returns:
    
    The results of this small scan operation. The return value will be wrapped by a CompletableFuture.
  - get
```
public List<CompletableFuture<Result>> get(List<Get> gets)
```
    Description copied from interface: AsyncTable
    
    Extracts certain cells from the given rows, in batch.
    Notice that you may not get all the results with this function, which means some of the returned CompletableFutures may succeed while some of the other returned CompletableFutures may fail.
    
    Specified by:
    
    get in interface AsyncTable<AdvancedScanResultConsumer>
    
    Parameters:
    
    gets - The objects that specify what data to fetch and from which rows.
    
    Returns:
    
    A list of CompletableFutures that represent the result for each get.
  - put
```
public List<CompletableFuture<Void>> put(List<Put> puts)
```
    Description copied from interface: AsyncTable
    
    Puts some data in the table, in batch.
    
    Specified by:
    
    put in interface AsyncTable<AdvancedScanResultConsumer>
    
    Parameters:
    
    puts - The list of mutations to apply.
    
    Returns:
    
    A list of CompletableFutures that represent the result for each put.
  - delete
```
public List<CompletableFuture<Void>> delete(List<Delete> deletes)
```
    Description copied from interface: AsyncTable
    
    Deletes the specified cells/rows in bulk.
    
    Specified by:
    
    delete in interface AsyncTable<AdvancedScanResultConsumer>
    
    Parameters:
    
    deletes - list of things to delete.
    
    Returns:
    
    A list of CompletableFutures that represent the result for each delete.
  - batch
```
public <T> List<CompletableFuture<T>> batch(List<? extends Row> actions)
```
    Description copied from interface: AsyncTable
    
    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 AsyncTable.batch(java.util.List<? extends org.apache.hadoop.hbase.client.Row>) call, you will not necessarily be guaranteed that the Get returns what the Put had put.
    
    Specified by:
    
    batch in interface AsyncTable<AdvancedScanResultConsumer>
    
    Parameters:
    
    actions - list of Get, Put, Delete, Increment, Append, and RowMutations objects
    
    Returns:
    
    A list of CompletableFutures that represent the result for each action.
  - voidMutate
```
private List<CompletableFuture<Void>> voidMutate(List<? extends Row> actions)
```
  - batch
```
private <T> List<CompletableFuture<T>> batch(List<? extends Row> actions,
                                             long rpcTimeoutNs)
```
  - getRpcTimeout
```
public long getRpcTimeout(TimeUnit unit)
```
    Description copied from interface: AsyncTable
    
    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 AsyncTable<AdvancedScanResultConsumer>
    
    Parameters:
    
    unit - the unit of time the timeout to be represented in
    
    Returns:
    
    rpc timeout in the specified time unit
    
    See Also:
    
    AsyncTable.getReadRpcTimeout(TimeUnit), AsyncTable.getWriteRpcTimeout(TimeUnit)
  - getReadRpcTimeout
```
public long getReadRpcTimeout(TimeUnit unit)
```
    Description copied from interface: AsyncTable
    
    Get timeout of each rpc read request in this Table instance.
    
    Specified by:
    
    getReadRpcTimeout in interface AsyncTable<AdvancedScanResultConsumer>
    
    Parameters:
    
    unit - the unit of time the timeout to be represented in
    
    Returns:
    
    read rpc timeout in the specified time unit
  - getWriteRpcTimeout
```
public long getWriteRpcTimeout(TimeUnit unit)
```
    Description copied from interface: AsyncTable
    
    Get timeout of each rpc write request in this Table instance.
    
    Specified by:
    
    getWriteRpcTimeout in interface AsyncTable<AdvancedScanResultConsumer>
    
    Parameters:
    
    unit - the unit of time the timeout to be represented in
    
    Returns:
    
    write rpc timeout in the specified time unit
  - getOperationTimeout
```
public long getOperationTimeout(TimeUnit unit)
```
    Description copied from interface: AsyncTable
    
    Get timeout of each operation in Table instance.
    
    Specified by:
    
    getOperationTimeout in interface AsyncTable<AdvancedScanResultConsumer>
    
    Parameters:
    
    unit - the unit of time the timeout to be represented in
    
    Returns:
    
    operation rpc timeout in the specified time unit
  - getScanTimeout
```
public long getScanTimeout(TimeUnit unit)
```
    Description copied from interface: AsyncTable
    
    Get the timeout of a single operation in a scan. It works like operation timeout for other operations.
    
    Specified by:
    
    getScanTimeout in interface AsyncTable<AdvancedScanResultConsumer>
    
    Parameters:
    
    unit - the unit of time the timeout to be represented in
    
    Returns:
    
    scan rpc timeout in the specified time unit
  - coprocessorService
```
private <S,R> CompletableFuture<R> coprocessorService(Function<com.google.protobuf.RpcChannel,S> stubMaker,
                                                      ServiceCaller<S,R> callable,
                                                      RegionInfo region,
                                                      byte[] row)
```
  - coprocessorService
```
public <S,R> CompletableFuture<R> coprocessorService(Function<com.google.protobuf.RpcChannel,S> stubMaker,
                                                     ServiceCaller<S,R> callable,
                                                     byte[] row)
```
    Description copied from interface: AsyncTable
    Execute the given coprocessor call on the region which contains the given row.
    The stubMaker is just a delegation to the newStub call. Usually it is only a one line lambda expression, like:
```
 channel -> xxxService.newStub(channel)
 
```
    Specified by:
    
    coprocessorService in interface AsyncTable<AdvancedScanResultConsumer>
    
    Type Parameters:
    
    S - the type of the asynchronous stub
    
    R - the type of the return value
    
    Parameters:
    
    stubMaker - a delegation to the actual newStub call.
    
    callable - a delegation to the actual protobuf rpc call. See the comment of ServiceCaller for more details.
    
    row - The row key used to identify the remote region location
    
    Returns:
    
    the return value of the protobuf rpc call, wrapped by a CompletableFuture.
    
    See Also:
    
    ServiceCaller
  - locateFinished
```
private boolean locateFinished(RegionInfo region,
                               byte[] endKey,
                               boolean endKeyInclusive)
```
  - onLocateComplete
```
private <S,R> void onLocateComplete(Function<com.google.protobuf.RpcChannel,S> stubMaker,
                                    ServiceCaller<S,R> callable,
                                    AsyncTable.CoprocessorCallback<R> callback,
                                    List<HRegionLocation> locs,
                                    byte[] endKey,
                                    boolean endKeyInclusive,
                                    AtomicBoolean locateFinished,
                                    AtomicInteger unfinishedRequest,
                                    HRegionLocation loc,
                                    Throwable error)
```
  - coprocessorService
```
public <S,R> AsyncTable.CoprocessorServiceBuilder<S,R> coprocessorService(Function<com.google.protobuf.RpcChannel,S> stubMaker,
                                                                          ServiceCaller<S,R> callable,
                                                                          AsyncTable.CoprocessorCallback<R> callback)
```
    Description copied from interface: AsyncTable
    Execute a coprocessor call on the regions which are covered by a range.
    Use the returned AsyncTable.CoprocessorServiceBuilder construct your request and then execute it.
    The stubMaker is just a delegation to the xxxService.newStub call. Usually it is only a one line lambda expression, like:
```
 channel -> xxxService.newStub(channel)
 
```
    Specified by:
    
    coprocessorService in interface AsyncTable<AdvancedScanResultConsumer>
    
    Parameters:
    
    stubMaker - a delegation to the actual newStub call.
    
    callable - a delegation to the actual protobuf rpc call. See the comment of ServiceCaller for more details.
    
    callback - callback to get the response. See the comment of AsyncTable.CoprocessorCallback for more details.

Class RawAsyncTableImpl

Nested Class Summary

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

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

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

Field Detail

LOG

conn

retryTimer

tableName

defaultScannerCaching

defaultScannerMaxResultSize

rpcTimeoutNs

readRpcTimeoutNs

writeRpcTimeoutNs

operationTimeoutNs

scanTimeoutNs

pauseNs

pauseNsForServerOverloaded

maxAttempts

startLogErrorsCnt

Constructor Detail

RawAsyncTableImpl

Method Detail

getName

getConfiguration

getDescriptor

getRegionLocator

call

mutate

voidMutate

toResult

noncedMutate

newCaller

newCaller

get

newTableOperationSpanBuilder

get

put

delete

append

increment

checkAndMutate

checkAndMutate

checkAndMutate

checkAndMutate

mutateRow

mutateRow

setDefaultScanConfig

scan

resultSize2CacheSize

getScanner

scanAll

get

put

delete

batch

voidMutate

batch

getRpcTimeout

getReadRpcTimeout

getWriteRpcTimeout

getOperationTimeout

getScanTimeout

coprocessorService

coprocessorService

locateFinished

onLocateComplete

coprocessorService