RawAsyncTableImpl (Apache HBase 2.3.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`	`pauseForCQTBENs`
`private long`	`pauseNs`
`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.
`<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.
`ResultScanner`	`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 <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<Result,RESP> respConverter)`
`CompletableFuture<Void>`	`mutateRow(RowMutations mutation)` 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 <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, 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
```

pauseForCQTBENs
```
private final long pauseForCQTBENs
```

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)
```
- 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>
- mutateRow
```
private <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<Result,RESP> respConverter)
```
- mutateRow
```
public CompletableFuture<Void> mutateRow(RowMutations mutation)
```
  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:
  
  mutation - object that specifies the set of mutations to perform atomically
  
  Returns:
  
  A CompletableFuture that always returns null when complete normally.
- 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 ResultScanner 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

pauseForCQTBENs

maxAttempts

startLogErrorsCnt

Constructor Detail

RawAsyncTableImpl

Method Detail

getName

getConfiguration

getDescriptor

getRegionLocator

call

mutate

voidMutate

toResult

noncedMutate

newCaller

newCaller

get

get

put

delete

append

increment

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