ThriftTable (Apache HBase 2.5.0 API)

java.lang.Object
- org.apache.hadoop.hbase.thrift2.client.ThriftTable

All Implemented Interfaces:: Closeable, AutoCloseable, Table

@InterfaceAudience.Private
public class ThriftTable
extends Object
implements Table

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`private class`	`ThriftTable.CheckAndMutateBuilderImpl`
`private class`	`ThriftTable.Scanner` A scanner to perform scan from thrift server getScannerResults is used in this scanner

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

Field Summary

Fields
Modifier and Type	Field and Description
`private org.apache.hadoop.hbase.thrift2.generated.THBaseService.Client`	`client`
`private org.apache.hadoop.conf.Configuration`	`conf`
`private int`	`operationTimeout`
`private int`	`scannerCaching`
`private TableName`	`tableName`
`private ByteBuffer`	`tableNameInBytes`
`private org.apache.thrift.transport.TTransport`	`tTransport`

Constructor Summary

Constructors
Constructor and Description
`ThriftTable(TableName tableName, org.apache.hadoop.hbase.thrift2.generated.THBaseService.Client client, org.apache.thrift.transport.TTransport tTransport, org.apache.hadoop.conf.Configuration conf)`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`Result`	`append(Append append)` Appends values to one or more columns within a single row.
`void`	`batch(List<? extends Row> actions, Object[] results)` Method that does a batch call on Deletes, Gets, Puts, Increments, Appends, RowMutations.
`<R> void`	`batchCallback(List<? extends Row> actions, Object[] results, Batch.Callback<R> callback)` Same as `Table.batch(List, Object[])`, but with a callback.
`Table.CheckAndMutateBuilder`	`checkAndMutate(byte[] row, byte[] family)` Atomically checks if a row/family/qualifier value matches the expected value.
`boolean`	`checkAndMutate(byte[] row, byte[] family, byte[] qualifier, CompareOperator op, byte[] value, RowMutations mutation)` Atomically checks if a row/family/qualifier value matches the expected value.
`Table.CheckAndMutateWithFilterBuilder`	`checkAndMutate(byte[] row, Filter filter)` Atomically checks if a row matches the specified filter.
`CheckAndMutateResult`	`checkAndMutate(CheckAndMutate checkAndMutate)` checkAndMutate that atomically checks if a row matches the specified condition.
`List<CheckAndMutateResult>`	`checkAndMutate(List<CheckAndMutate> checkAndMutates)` Batch version of checkAndMutate.
`void`	`close()` Releases any resources held or pending changes in internal buffers.
`CoprocessorRpcChannel`	`coprocessorService(byte[] row)` Creates and returns a `RpcChannel` instance connected to the table region containing the specified row.
`void`	`delete(Delete delete)` Deletes the specified cells/row.
`void`	`delete(List<Delete> deletes)` Batch Deletes the specified cells/rows from the table.
`boolean`	`exists(Get get)` Test for the existence of columns in the table, as specified by the Get.
`boolean[]`	`exists(List<Get> gets)` Test for the existence of columns in the table, as specified by the Gets.
`Result`	`get(Get get)` Extracts certain cells from a given row.
`Result[]`	`get(List<Get> gets)` Extracts specified cells from the given rows, as a batch.
`org.apache.hadoop.conf.Configuration`	`getConfiguration()` Returns the `Configuration` object used by this instance.
`TableDescriptor`	`getDescriptor()` Gets the `table descriptor` 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.
`RegionLocator`	`getRegionLocator()` Gets the `RegionLocator` for this table.
`long`	`getRpcTimeout(TimeUnit unit)` Get timeout of each rpc request in this Table instance.
`ResultScanner`	`getScanner(byte[] family)` Gets a scanner on the current table for the given family.
`ResultScanner`	`getScanner(byte[] family, byte[] qualifier)` Gets a scanner on the current table for the given family and qualifier.
`ResultScanner`	`getScanner(Scan scan)` Returns a scanner on the current table as specified by the `Scan` object.
`long`	`getWriteRpcTimeout(TimeUnit unit)` Get timeout of each rpc write request in this Table instance.
`Result`	`increment(Increment increment)` Increments one or more columns within a single row.
`Result`	`mutateRow(RowMutations rm)` Performs multiple mutations atomically on a single row.
`void`	`put(List<Put> puts)` Batch puts the specified data into the table.
`void`	`put(Put put)` Puts some data in the table.

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.Table
batchCoprocessorService, batchCoprocessorService, checkAndDelete, checkAndDelete, checkAndDelete, checkAndMutate, checkAndPut, checkAndPut, checkAndPut, coprocessorService, coprocessorService, existsAll, getOperationTimeout, getReadRpcTimeout, getRpcTimeout, getTableDescriptor, getWriteRpcTimeout, incrementColumnValue, incrementColumnValue, setOperationTimeout, setReadRpcTimeout, setRpcTimeout, setWriteRpcTimeout

- Field Detail
  - tableName
```
private TableName tableName
```
  - conf
```
private org.apache.hadoop.conf.Configuration conf
```
  - tTransport
```
private org.apache.thrift.transport.TTransport tTransport
```
  - client
```
private org.apache.hadoop.hbase.thrift2.generated.THBaseService.Client client
```
  - tableNameInBytes
```
private ByteBuffer tableNameInBytes
```
  - operationTimeout
```
private int operationTimeout
```
  - scannerCaching
```
private final int scannerCaching
```
- Constructor Detail
  - ThriftTable
```
public ThriftTable(TableName tableName,
                   org.apache.hadoop.hbase.thrift2.generated.THBaseService.Client client,
                   org.apache.thrift.transport.TTransport tTransport,
                   org.apache.hadoop.conf.Configuration conf)
```
- Method Detail
  - getName
```
public TableName getName()
```
    Description copied from interface: Table
    
    Gets the fully qualified table name instance of this table.
    
    Specified by:
    
    getName in interface Table
  - getConfiguration
```
public org.apache.hadoop.conf.Configuration getConfiguration()
```
    Description copied from interface: Table
    
    Returns the Configuration object used by this instance.
    The reference returned is not a copy, so any change made to it will affect this instance.
    
    Specified by:
    
    getConfiguration in interface Table
  - getDescriptor
```
public TableDescriptor getDescriptor()
                              throws IOException
```
    Description copied from interface: Table
    
    Gets the table descriptor for this table.
    
    Specified by:
    
    getDescriptor in interface Table
    
    Throws:
    
    IOException - if a remote or network exception occurs.
  - exists
```
public boolean exists(Get get)
               throws IOException
```
    Description copied from interface: Table
    
    Test for the existence of columns in the table, as specified by the Get.
    This will return true if the Get matches one or more keys, false if not.
    This is a server-side call so it prevents any data from being transfered to the client.
    
    Specified by:
    
    exists in interface Table
    
    Parameters:
    
    get - the Get
    
    Returns:
    
    true if the specified Get matches one or more keys, false if not
    
    Throws:
    
    IOException - e
  - exists
```
public boolean[] exists(List<Get> gets)
                 throws IOException
```
    Description copied from interface: Table
    
    Test for the existence of columns in the table, as specified by the Gets.
    This will return an array of booleans. Each value will be true if the related Get matches one or more keys, false if not.
    This is a server-side call so it prevents any data from being transferred to the client.
    
    Specified by:
    
    exists in interface Table
    
    Parameters:
    
    gets - the Gets
    
    Returns:
    
    Array of boolean. True if the specified Get matches one or more keys, false if not.
    
    Throws:
    
    IOException - e
  - batch
```
public void batch(List<? extends Row> actions,
                  Object[] results)
           throws IOException
```
    Description copied from interface: Table
    
    Method that does a batch call on Deletes, Gets, Puts, Increments, Appends, RowMutations. The ordering of execution of the actions is not defined. Meaning if you do a Put and a Get in the same Table.batch(java.util.List<? extends org.apache.hadoop.hbase.client.Row>, java.lang.Object[]) call, you will not necessarily be guaranteed that the Get returns what the Put had put.
    
    Specified by:
    
    batch in interface Table
    
    Parameters:
    
    actions - list of Get, Put, Delete, Increment, Append, RowMutations.
    
    results - Empty Object[], same size as actions. Provides access to partial results, in case an exception is thrown. A null in the result array means that the call for that action failed, even after retries. The order of the objects in the results array corresponds to the order of actions in the request list. n * @since 0.90.0
    
    Throws:
    
    IOException
  - batchCallback
```
public <R> void batchCallback(List<? extends Row> actions,
                              Object[] results,
                              Batch.Callback<R> callback)
                       throws IOException
```
    Description copied from interface: Table
    
    Same as Table.batch(List, Object[]), but with a callback.
    
    Specified by:
    
    batchCallback in interface Table
    
    Throws:
    
    IOException
  - get
```
public Result get(Get get)
           throws IOException
```
    Description copied from interface: Table
    
    Extracts certain cells from a given row.
    
    Specified by:
    
    get in interface Table
    
    Parameters:
    
    get - The object that specifies what data to fetch and from which row.
    
    Returns:
    
    The data coming from the specified row, if it exists. If the row specified doesn't exist, the Result instance returned won't contain any KeyValue, as indicated by Result.isEmpty().
    
    Throws:
    
    IOException - if a remote or network exception occurs.
  - get
```
public Result[] get(List<Get> gets)
             throws IOException
```
    Description copied from interface: Table
    
    Extracts specified cells from the given rows, as a batch.
    
    Specified by:
    
    get in interface Table
    
    Parameters:
    
    gets - The objects that specify what data to fetch and from which rows.
    
    Returns:
    
    The data coming from the specified rows, if it exists. If the row specified doesn't exist, the Result instance returned won't contain any Cells, as indicated by Result.isEmpty(). If there are any failures even after retries, there will be a null in the results' array for those Gets, AND an exception will be thrown. The ordering of the Result array corresponds to the order of the list of passed in Gets.
    
    Throws:
    
    IOException - if a remote or network exception occurs.
  - getScanner
```
public ResultScanner getScanner(Scan scan)
                         throws IOException
```
    Description copied from interface: Table
    
    Returns a scanner on the current table as specified by the Scan object. Note that the passed Scan's start row and caching properties maybe changed.
    
    Specified by:
    
    getScanner in interface Table
    
    Parameters:
    
    scan - A configured Scan object.
    
    Returns:
    
    A scanner.
    
    Throws:
    
    IOException - if a remote or network exception occurs.
  - getScanner
```
public ResultScanner getScanner(byte[] family)
                         throws IOException
```
    Description copied from interface: Table
    
    Gets a scanner on the current table for the given family.
    
    Specified by:
    
    getScanner in interface Table
    
    Parameters:
    
    family - The column family to scan.
    
    Returns:
    
    A scanner.
    
    Throws:
    
    IOException - if a remote or network exception occurs.
  - getScanner
```
public ResultScanner getScanner(byte[] family,
                                byte[] qualifier)
                         throws IOException
```
    Description copied from interface: Table
    
    Gets a scanner on the current table for the given family and qualifier.
    
    Specified by:
    
    getScanner in interface Table
    
    Parameters:
    
    family - The column family to scan.
    
    qualifier - The column qualifier to scan.
    
    Returns:
    
    A scanner.
    
    Throws:
    
    IOException - if a remote or network exception occurs.
  - put
```
public void put(Put put)
         throws IOException
```
    Description copied from interface: Table
    
    Puts some data in the table.
    
    Specified by:
    
    put in interface Table
    
    Parameters:
    
    put - The data to put.
    
    Throws:
    
    IOException - if a remote or network exception occurs.
  - put
```
public void put(List<Put> puts)
         throws IOException
```
    Description copied from interface: Table
    
    Batch puts the specified data into the table.
    This can be used for group commit, or for submitting user defined batches. Before sending a batch of mutations to the server, the client runs a few validations on the input list. If an error is found, for example, a mutation was supplied but was missing it's column an IllegalArgumentException will be thrown and no mutations will be applied. If there are any failures even after retries, a RetriesExhaustedWithDetailsException will be thrown. RetriesExhaustedWithDetailsException contains lists of failed mutations and corresponding remote exceptions. The ordering of mutations and exceptions in the encapsulating exception corresponds to the order of the input list of Put requests.
    
    Specified by:
    
    put in interface Table
    
    Parameters:
    
    puts - The list of mutations to apply.
    
    Throws:
    
    IOException - if a remote or network exception occurs.
  - delete
```
public void delete(Delete delete)
            throws IOException
```
    Description copied from interface: Table
    
    Deletes the specified cells/row.
    
    Specified by:
    
    delete in interface Table
    
    Parameters:
    
    delete - The object that specifies what to delete.
    
    Throws:
    
    IOException - if a remote or network exception occurs.
  - delete
```
public void delete(List<Delete> deletes)
            throws IOException
```
    Description copied from interface: Table
    
    Batch Deletes the specified cells/rows from the table.
    If a specified row does not exist, Delete will report as though sucessful delete; no exception will be thrown. If there are any failures even after retries, a RetriesExhaustedWithDetailsException will be thrown. RetriesExhaustedWithDetailsException contains lists of failed Deletes and corresponding remote exceptions.
    
    Specified by:
    
    delete in interface Table
    
    Parameters:
    
    deletes - List of things to delete. The input list gets modified by this method. All successfully applied Deletes in the list are removed (in particular it gets re-ordered, so the order in which the elements are inserted in the list gives no guarantee as to the order in which the Deletes are executed).
    
    Throws:
    
    IOException - if a remote or network exception occurs. In that case the deletes argument will contain the Delete instances that have not be successfully applied.
  - checkAndMutate
```
public boolean checkAndMutate(byte[] row,
                              byte[] family,
                              byte[] qualifier,
                              CompareOperator op,
                              byte[] value,
                              RowMutations mutation)
                       throws IOException
```
    Description copied from interface: Table
    
    Atomically checks if a row/family/qualifier value matches the expected value. If it does, it performs the row mutations. If the passed value is null, the check is for the lack of column (ie: non-existence) The expected value argument of this call is on the left and the current value of the cell is on the right side of the comparison operator. Ie. eg. GREATER operator means expected value > existing <=> perform row mutations.
    
    Specified by:
    
    checkAndMutate in interface Table
    
    Parameters:
    
    row - to check
    
    family - column family to check
    
    qualifier - column qualifier to check
    
    op - the comparison operator
    
    value - the expected value
    
    mutation - mutations to perform if check succeeds
    
    Returns:
    
    true if the new put was executed, false otherwise
    
    Throws:
    
    IOException - e
  - checkAndMutate
```
public Table.CheckAndMutateBuilder checkAndMutate(byte[] row,
                                                  byte[] family)
```
    Description copied from interface: Table
    Atomically checks if a row/family/qualifier value matches the expected value. If it does, it adds the Put/Delete/RowMutations.
    Use the returned Table.CheckAndMutateBuilder to construct your request and then execute it. This is a fluent style API, the code is like:
```
 
 table.checkAndMutate(row, family).qualifier(qualifier).ifNotExists().thenPut(put);
 
 
```
    Specified by:
    
    checkAndMutate in interface Table
  - checkAndMutate
```
public Table.CheckAndMutateWithFilterBuilder checkAndMutate(byte[] row,
                                                            Filter filter)
```
    Description copied from interface: Table
    Atomically checks if a row matches the specified filter. If it does, it adds the Put/Delete/RowMutations.
    Use the returned Table.CheckAndMutateWithFilterBuilder to construct your request and then execute it. This is a fluent style API, the code is like:
```
 
 table.checkAndMutate(row, filter).thenPut(put);
 
 
```
    Specified by:
    
    checkAndMutate in interface Table
  - checkAndMutate
```
public CheckAndMutateResult checkAndMutate(CheckAndMutate checkAndMutate)
```
    Description copied from interface: Table
    
    checkAndMutate that atomically checks if a row matches the specified condition. If it does, it performs the specified action.
    
    Specified by:
    
    checkAndMutate in interface Table
    
    Parameters:
    
    checkAndMutate - The CheckAndMutate object.
    
    Returns:
    
    A CheckAndMutateResult object that represents the result for the CheckAndMutate.
  - checkAndMutate
```
public List<CheckAndMutateResult> checkAndMutate(List<CheckAndMutate> checkAndMutates)
```
    Description copied from interface: Table
    
    Batch version of checkAndMutate. The specified CheckAndMutates are batched only in the sense that they are sent to a RS in one RPC, but each CheckAndMutate operation is still executed atomically (and thus, each may fail independently of others).
    
    Specified by:
    
    checkAndMutate in interface Table
    
    Parameters:
    
    checkAndMutates - The list of CheckAndMutate.
    
    Returns:
    
    A list of CheckAndMutateResult objects that represents the result for each CheckAndMutate.
  - mutateRow
```
public Result mutateRow(RowMutations rm)
                 throws IOException
```
    Description copied from interface: Table
    
    Performs multiple mutations atomically on a single row. Currently Put and Delete are supported.
    
    Specified by:
    
    mutateRow in interface Table
    
    Parameters:
    
    rm - object that specifies the set of mutations to perform atomically
    
    Returns:
    
    results of Increment/Append operations
    
    Throws:
    
    IOException - if a remote or network exception occurs.
  - append
```
public Result append(Append append)
              throws IOException
```
    Description copied from interface: Table
    
    Appends values to one or more columns within a single row.
    This operation guaranteed atomicity to readers. Appends are done under a single row lock, so write operations to a row are synchronized, and readers are guaranteed to see this operation fully completed.
    
    Specified by:
    
    append in interface Table
    
    Parameters:
    
    append - object that specifies the columns and values to be appended
    
    Returns:
    
    values of columns after the append operation (maybe null)
    
    Throws:
    
    IOException - e
  - increment
```
public Result increment(Increment increment)
                 throws IOException
```
    Description copied from interface: Table
    
    Increments one or more columns within a single row.
    This operation ensures atomicity to readers. Increments are done under a single row lock, so write operations to a row are synchronized, and readers are guaranteed to see this operation fully completed.
    
    Specified by:
    
    increment in interface Table
    
    Parameters:
    
    increment - object that specifies the columns and amounts to be used for the increment operations
    
    Returns:
    
    values of columns after the increment
    
    Throws:
    
    IOException - e
  - close
```
public void close()
           throws IOException
```
    Description copied from interface: Table
    
    Releases any resources held or pending changes in internal buffers.
    
    Specified by:
    
    close in interface Closeable
    
    Specified by:
    
    close in interface AutoCloseable
    
    Specified by:
    
    close in interface Table
    
    Throws:
    
    IOException - if a remote or network exception occurs.
  - getRpcTimeout
```
public long getRpcTimeout(TimeUnit unit)
```
    Description copied from interface: Table
    
    Get timeout of each rpc request in this Table instance. It will be overridden by a more specific rpc timeout config such as readRpcTimeout or writeRpcTimeout.
    
    Specified by:
    
    getRpcTimeout in interface Table
    
    Parameters:
    
    unit - the unit of time the timeout to be represented in
    
    Returns:
    
    rpc timeout in the specified time unit
    
    See Also:
    
    Table.getReadRpcTimeout(TimeUnit), Table.getWriteRpcTimeout(TimeUnit)
  - getReadRpcTimeout
```
public long getReadRpcTimeout(TimeUnit unit)
```
    Description copied from interface: Table
    
    Get timeout of each rpc read request in this Table instance.
    
    Specified by:
    
    getReadRpcTimeout in interface Table
    
    Parameters:
    
    unit - the unit of time the timeout to be represented in
    
    Returns:
    
    read rpc timeout in the specified time unit
  - getWriteRpcTimeout
```
public long getWriteRpcTimeout(TimeUnit unit)
```
    Description copied from interface: Table
    
    Get timeout of each rpc write request in this Table instance.
    
    Specified by:
    
    getWriteRpcTimeout in interface Table
    
    Parameters:
    
    unit - the unit of time the timeout to be represented in
    
    Returns:
    
    write rpc timeout in the specified time unit
  - getOperationTimeout
```
public long getOperationTimeout(TimeUnit unit)
```
    Description copied from interface: Table
    
    Get timeout of each operation in Table instance.
    
    Specified by:
    
    getOperationTimeout in interface Table
    
    Parameters:
    
    unit - the unit of time the timeout to be represented in
    
    Returns:
    
    operation rpc timeout in the specified time unit
  - coprocessorService
```
public CoprocessorRpcChannel coprocessorService(byte[] row)
```
    Description copied from interface: Table
    Creates and returns a RpcChannel instance connected to the table region containing the specified row. The row given does not actually have to exist. Whichever region would contain the row based on start and end keys will be used. Note that the row parameter is also not passed to the coprocessor handler registered for this protocol, unless the row is separately passed as an argument in the service request. The parameter here is only used to locate the region used to handle the call.
    The obtained RpcChannel instance can be used to access a published coprocessor Service using standard protobuf service invocations:
    CoprocessorRpcChannel channel = myTable.coprocessorService(rowkey); MyService.BlockingInterface service = MyService.newBlockingStub(channel); MyCallRequest request = MyCallRequest.newBuilder() ... .build(); MyCallResponse response = service.myCall(null, request);
    Specified by:
    
    coprocessorService in interface Table
    
    Parameters:
    
    row - The row key used to identify the remote region location
    
    Returns:
    
    A CoprocessorRpcChannel instance
  - getRegionLocator
```
public RegionLocator getRegionLocator()
                               throws IOException
```
    Description copied from interface: Table
    
    Gets the RegionLocator for this table.
    
    Specified by:
    
    getRegionLocator in interface Table
    
    Throws:
    
    IOException

Class ThriftTable

Nested Class Summary

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

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

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

Field Detail

tableName

conf

tTransport

client

tableNameInBytes

operationTimeout

scannerCaching

Constructor Detail

ThriftTable

Method Detail

getName

getConfiguration

getDescriptor

exists

exists

batch

batchCallback

get

get

getScanner

getScanner

getScanner

put

put

delete

delete

checkAndMutate

checkAndMutate

checkAndMutate

checkAndMutate

checkAndMutate

mutateRow

append

increment

close

getRpcTimeout

getReadRpcTimeout

getWriteRpcTimeout

getOperationTimeout

coprocessorService

getRegionLocator