org.apache.hadoop.hbase.client

Class RawAsyncTableImpl

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 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.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

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.
<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.
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.
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>

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>

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.