org.apache.hadoop.hbase.client (Apache HBase - Client 0.98.19-hadoop2 API)

Interface Summary
Attributes
HConnection	A cluster connection.
HTableInterface	Used to communicate with a single HBase table.
HTableInterfaceFactory	Defines methods to create new HTableInterface.
MetaScanner.MetaScannerVisitor	Visitor class called to process each row of the hbase:meta table
NonceGenerator	NonceGenerator interface.
ResultScanner	Interface for client-side scanning.
RetryingCallable<T>	A Callable that will be retried.
Row	Has a row.
StatisticsHConnection	A server statistics tracking aware HConnection.
StatisticTrackable	Parent interface for an object to get updates about per-region statistics.

Class Summary
AbstractClientScanner	Helper class for custom client scanners.
Action<R>	A Get, Put, Increment, Append, or Delete associated with it's region.
Append	Performs Append operations on a single row.
ClientScanner	Implements the scanner interface for the HBase client.
ClientSmallReversedScanner	Client scanner for small reversed scan.
ClientSmallScanner	Client scanner for small scan.
ClientSmallScanner.SmallScannerCallableFactory
ConnectionUtils	Utility used by client connections.
DelayingRunner<T>	A wrapper for a runnable for a group of actions for a single regionserver.
DelegatingRetryingCallable<T,D extends RetryingCallable<T>>	Helper callable for internal use when you just want to override a single method of a `RetryingCallable`.
Delete	Used to perform Delete operations on a single row.
Get	Used to perform Get operations on a single row.
HBaseAdmin	Provides an interface to manage HBase database table metadata + general administrative functions.
HConnectable<T>	This class makes it convenient for one to execute a command in the context of a `HConnection` instance based on the given `Configuration`.
HConnectionManager	A non-instantiable class that manages creation of `HConnection`s.
HConnectionManager.HConnectionImplementation	Encapsulates connection to zookeeper and regionservers.
HTable	Used to communicate with a single HBase table.
HTableFactory	Deprecated. as of 0.98.1.
HTableMultiplexer	HTableMultiplexer provides a thread-safe non blocking PUT API across all the tables.
HTableMultiplexer.HTableMultiplexerStatus	HTableMultiplexerStatus keeps track of the current status of the HTableMultiplexer.
HTablePool	Deprecated. as of 0.98.1.
HTableUtil	Utility class for HTable.
Increment	Used to perform Increment operations on a single row.
MetaScanner	Scanner class that contains the `hbase:meta` table scanning logic.
MetaScanner.DefaultMetaScannerVisitor	A MetaScannerVisitor that skips offline regions and split parents
MetaScanner.MetaScannerVisitorBase
MetaScanner.TableMetaScannerVisitor	A MetaScannerVisitor for a table.
MetricsConnection	This class is for maintaining the various connection statistics and publishing them through the metrics interfaces.
MetricsConnection.CallStats	A container class for collecting details about the RPC call as it percolates.
MetricsConnection.RegionStats
MetricsConnection.RunnerStats
MultiAction<R>	Container for Actions (i.e.
MultiResponse	A container for Result objects, grouped by regionName.
Mutation
Operation	Superclass for any type that maps to a potentially application-level query.
OperationWithAttributes
PayloadCarryingServerCallable<T>	This class is used to unify HTable calls with AsyncProcess Framework.
PerClientRandomNonceGenerator	NonceGenerator implementation that uses client ID hash + random int as nonce group, and random numbers as nonces.
Put	Used to perform Put operations for a single row.
Query
RegionCoprocessorServiceExec	Represents a coprocessor service method execution against a single region.
RegionServerCallable<T>	Implementations call a RegionServer and implement `Callable.call()`.
Result	Single row result of a `Get` or `Scan` query.
ResultStatsUtil	A `Result` with some statistics about the server/region status
RetriesExhaustedException.ThrowableWithExtraContext	Datastructure that allows adding more info around Throwable incident.
ReversedClientScanner	A reversed client scanner which support backward scanning
ReversedScannerCallable	A reversed ScannerCallable which supports backward scanning.
RowMutations	Performs multiple mutations atomically on a single row.
RpcRetryingCaller<T>	Dynamic rather than static so can set the generic return type appropriately.
RpcRetryingCallerFactory	Factory to create an `RpcRetryingCaller`
Scan	Used to perform Scan operations.
ScannerCallable	Scanner operations such as create, next, etc.
ServerStatisticTracker	Tracks the statistics for multiple regions
TableConfiguration	Configuration is a heavy weight registry that does a lot of string operations and regex matching.
UnmodifyableHTableDescriptor	Read-only table descriptor.

Enum Summary
Durability	Enum describing the durability guarantees for tables and `Mutation`s Note that the items must be sorted in order of increasing durability
IsolationLevel	Specify Isolation levels in Scan operations.

Exception Summary
NoServerForRegionException	Thrown when no region server can be found for a region
RegionOfflineException	Thrown when a table can not be located
RetriesExhaustedException	Exception thrown by HTable methods when an attempt to do something (like commit changes) fails after a bunch of retries.
RetriesExhaustedWithDetailsException	This subclass of `RetriesExhaustedException` is thrown when we have more information about which rows were causing which exceptions on what servers.
ScannerTimeoutException	Thrown when a scanner has timed out.
WrongRowIOException

To administer HBase, create and drop tables, list and alter tables, use HBaseAdmin. Once created, table access is via an instance of HTable. You add content to a table a row at a time. To insert, create an instance of a Put object. Specify value, target column and optionally a timestamp. Commit your update using HTable.put(Put). To fetch your inserted value, use Get. The Get can be specified to be broad -- get all on a particular row -- or narrow; i.e. return only a single cell value. After creating an instance of Get, invoke HTable.get(Get). Use Scan to set up a scanner -- a Cursor- like access. After creating and configuring your Scan instance, call HTable.getScanner(Scan) and then invoke next on the returned object. Both HTable.get(Get) and HTable.getScanner(Scan) return a Result. A Result is a List of KeyValues. It has facility for packaging the return in different formats. Use Delete to remove content. You can remove individual cells or entire families, etc. Pass it to HTable.delete(Delete) to execute.

Puts, Gets and Deletes take out a lock on the target row for the duration of their operation. Concurrent modifications to a single row are serialized. Gets and scans run concurrently without interference of the row locks and are guaranteed to not to return half written rows.

Client code accessing a cluster finds the cluster by querying ZooKeeper. This means that the ZooKeeper quorum to use must be on the client CLASSPATH. Usually this means make sure the client can find your hbase-site.xml.

Example API Usage

Once you have a running HBase, you probably want a way to hook your application up to it. If your application is in Java, then you should use the Java API. Here's an example of what a simple client might look like. This example assumes that you've created a table called "myTable" with a column family called "myColumnFamily".

import java.io.IOException;

import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.hbase.client.Get;
import org.apache.hadoop.hbase.client.HTable;
import org.apache.hadoop.hbase.client.Put;
import org.apache.hadoop.hbase.client.Result;
import org.apache.hadoop.hbase.client.ResultScanner;
import org.apache.hadoop.hbase.client.Scan;
import org.apache.hadoop.hbase.util.Bytes;


// Class that has nothing but a main.
// Does a Put, Get and a Scan against an hbase table.
public class MyLittleHBaseClient {
  public static void main(String[] args) throws IOException {
    // You need a configuration object to tell the client where to connect.
    // When you create a HBaseConfiguration, it reads in whatever you've set
    // into your hbase-site.xml and in hbase-default.xml, as long as these can
    // be found on the CLASSPATH
    Configuration config = HBaseConfiguration.create();

    // This instantiates an HTable object that connects you to
    // the "myLittleHBaseTable" table.
    HTable table = new HTable(config, "myLittleHBaseTable");

    // To add to a row, use Put.  A Put constructor takes the name of the row
    // you want to insert into as a byte array.  In HBase, the Bytes class has
    // utility for converting all kinds of java types to byte arrays.  In the
    // below, we are converting the String "myLittleRow" into a byte array to
    // use as a row key for our update. Once you have a Put instance, you can
    // adorn it by setting the names of columns you want to update on the row,
    // the timestamp to use in your update, etc.If no timestamp, the server
    // applies current time to the edits.
    Put p = new Put(Bytes.toBytes("myLittleRow"));

    // To set the value you'd like to update in the row 'myLittleRow', specify
    // the column family, column qualifier, and value of the table cell you'd
    // like to update.  The column family must already exist in your table
    // schema.  The qualifier can be anything.  All must be specified as byte
    // arrays as hbase is all about byte arrays.  Lets pretend the table
    // 'myLittleHBaseTable' was created with a family 'myLittleFamily'.
    p.add(Bytes.toBytes("myLittleFamily"), Bytes.toBytes("someQualifier"),
      Bytes.toBytes("Some Value"));

    // Once you've adorned your Put instance with all the updates you want to
    // make, to commit it do the following (The HTable#put method takes the
    // Put instance you've been building and pushes the changes you made into
    // hbase)
    table.put(p);

    // Now, to retrieve the data we just wrote. The values that come back are
    // Result instances. Generally, a Result is an object that will package up
    // the hbase return into the form you find most palatable.
    Get g = new Get(Bytes.toBytes("myLittleRow"));
    Result r = table.get(g);
    byte [] value = r.getValue(Bytes.toBytes("myLittleFamily"),
      Bytes.toBytes("someQualifier"));
    // If we convert the value bytes, we should get back 'Some Value', the
    // value we inserted at this location.
    String valueStr = Bytes.toString(value);
    System.out.println("GET: " + valueStr);

    // Sometimes, you won't know the row you're looking for. In this case, you
    // use a Scanner. This will give you cursor-like interface to the contents
    // of the table.  To set up a Scanner, do like you did above making a Put
    // and a Get, create a Scan.  Adorn it with column names, etc.
    Scan s = new Scan();
    s.addColumn(Bytes.toBytes("myLittleFamily"), Bytes.toBytes("someQualifier"));
    ResultScanner scanner = table.getScanner(s);
    try {
      // Scanners return Result instances.
      // Now, for the actual iteration. One way is to use a while loop like so:
      for (Result rr = scanner.next(); rr != null; rr = scanner.next()) {
        // print out the row we found and the columns we were looking for
        System.out.println("Found row: " + rr);
      }

      // The other approach is to use a foreach loop. Scanners are iterable!
      // for (Result rr : scanner) {
      //   System.out.println("Found row: " + rr);
      // }
    } finally {
      // Make sure you close your scanners when you are done!
      // Thats why we have it inside a try/finally clause
      scanner.close();
    }
  }
}

There are many other methods for putting data into and getting data out of HBase, but these examples should get you started. See the HTable javadoc for more methods. Additionally, there are methods for managing tables in the HBaseAdmin class.

If your client is NOT Java, then you should consider the Thrift or REST libraries.

Package org.apache.hadoop.hbase.client

Package org.apache.hadoop.hbase.client Description

Table of Contents

Overview

Example API Usage

Related Documentation