16 HBaseOperations

HBase Operations

Outline

HBase shell
Data definition commands
Data manipulation commands
HBase Java API

The HBase Shell is an interactive command-line interface used to communicate with and manage the Apache HBase distributed database.

Key Features and Operation

1. JRuby-based Interface

The HBase Shell is built on JRuby (Java Interactive Ruby), meaning it uses a Ruby interpreter running on the Java Virtual Machine (JVM). This allows users to leverage Ruby's scripting capabilities while interacting with the Java-based HBase system.

2. Read–Eval–Print-Loop (REPL)

It operates as a typical REPL (Read–Eval–Print-Loop) shell, also known as a language shell. This makes it an interactive environment:

Read: It waits for the user to input a single command or expression.

Eval (Evaluate): It executes or computes the input.

Print: It displays the result of the computation back to the user.

Loop: It then returns to the Read state, awaiting the next input.

This piecewise execution allows you to run commands one by one and immediately see the effect, which is ideal for administration, testing, and exploration.

3. Ruby Scripting Capabilities

Since it's built on JRuby, the shell allows for the computation of Ruby scripts and inherently includes all features enabled in the JIRB (Java Interactive Ruby) shell. This means you can do more than just execute basic HBase commands; you can use Ruby control structures, variables, and logic to automate tasks or perform complex operations.

4. Running Command Scripts

While typically used interactively, the shell can also execute a series of commands saved in a file. This is done using the source command:

source 'file-name.hb'

Here, the file (file-name.hb) contains a sequence of HBase shell commands (and optionally Ruby code) that the shell will execute non-interactively. This is useful for running batch operations, setting up a new table structure, or migrating data.

Typical Uses

Administration: Creating, dropping, enabling, or disabling tables.

Data Manipulation: Inserting, updating, deleting, and scanning data.

Monitoring: Checking the status of the cluster, servers, and tables.

Scripting: Automating repetitive administrative tasks or data loading/extraction routines using Ruby.

HBase shell

HBase provides extensible JRuby-based (Java Interactive Ruby - JIRB) shell as a feature to execute some commands
The shell is a typical Read–Eval–Print-Loop (REPL) shell also known as a language shell
It is a simple, interactive computer programming environment that takes single user inputs evaluates them, and returns the result to the user; a program written in a REPL environment is executed piecewise
It means that HBase shell allows for computation of Ruby scripts and brings all features enabled in JIRB shell
It allows to process a script of HBase commands saved in a file file-name.hb in the following way:

HBase Operations

HBase DDL commands are used to define and manage the structure (schema) of tables. The list you provided includes the core administrative commands for table lifecycle management.

1. create Command

The create command is used to make a new table in HBase. It requires the table name and at least one column family name.

create 'TABLE_NAME', 'COLUMN_FAMILY' create 'student','personal' Creates a table named 'student' with one column family named 'personal'.

2. list and describe Commands

These commands are used for table inspection.

list Shows a list of all tables in HBase.

describe 'student' Displays the complete structure (schema) of the specified table, including column families, their properties (like versions, in-memory status, compression), and regionsplit keys.

3. alter Command

The alter command is used to modify the structure or properties of an existing table. Since you cannot modify a table that is currently active, you must typically disable the table before using alter and then enable it afterward, though some changes (like adding a column family) can be done without disabling in newer versions of HBase.

The alter command uses key-value pairs ({KEY=>VALUE}) to specify the change.

A. Implementing a Column Family in Transient Memory (In-Memory)

This modification changes a column family's property so that its data will be preferentially stored in the RegionServer's block cache (transient memory) for faster reads.

alter 'TABLE', {NAME=>'CF_NAME', IN_MEMORY=>true} alter 'student',{NAME=>'personal',IN_MEMORY=>true} Modifies the 'personal' column family in the 'student' table to be kept in-memory.

B. Adding a New Column Family

You can use alter to add new column families to a table. You can also specify properties for the new family, like the number of versions to keep.

alter 'TABLE', {NAME=>'CF_NAME', VERSIONS=>'N'} alter 'student',{NAME=>'uni',VERSIONS=>'4'} Adds a new column family named 'uni' to the 'student' table and configures it to keep 4 versions of each cell value.

Other DDL Commands

disable 'table_name' / enable 'table_name': Takes a table offline/brings it online. Necessary before and after certain structural changes (alter).

drop 'table_name': Deletes a table. A table must be disabled before it can be dropped.

disable_all / enable_all / drop_all: Perform the respective action on all tables matching a given regular expression pattern.

show_filters: Displays a list of available filter classes that can be used in data retrieval operations.

alter_status: Used to view the status of an alter command that is running in the background.

Data definition commands

In Hbase, a set of data definition commands includes: create, list, describe, disable, disable_all, enable, enable_all, drop, drop_all, show_filters, alter, alter_status
Create a table 'student' with a column family 'personal'
Show a structure of a table 'student'
Implement a column family 'personal' in transient memory

Add a column family 'uni' to a table 'student'

alter 'student',{NAME=>'uni',VERSIONS=>'4'}

Advanced alter Command Usage

The alter command is the primary tool for modifying the structure of an existing HBase table.

1. Deleting a Column Family ('delete')

To remove an entire column family and all the data it contains from a table, you use the special 'delete' option within the alter command.

Delete Column Family alter 'student','delete'=>'uni' This command removes the column family named 'uni' from the 'student' table, permanently deleting all data associated with that family.

2. Adding a Column Family with Version Limit

When adding a new column family, you can specify its properties, such as the maximum number of cell versions (historical values) to retain.

Add CF with Versions alter 'student',{NAME=>'university',VERSIONS=>5} This adds a new column family named 'university' to the 'student' table and configures it to keep up to 5 versions of data for every cell (column qualifier) within this family.

3. Modifying an Existing Column Family's Properties

You can use alter to change the properties of an existing column family, such as increasing or decreasing the number of versions kept.

Modify CF Property alter 'student',{NAME=>'personal',VERSIONS=>3} This modifies the existing column family 'personal' in the 'student' table, setting its maximum number of cell versions to 3.

Important Note on alter

For major structural changes like adding, modifying, or deleting a column family, HBase historically required the table to be disabled first, and then enabled after the alter command completed.

# General workflow for older HBase versions or complex changes:

disable 'student'

alter 'student', ... (your change command)

enable 'student'

However, newer versions of HBase often allow column family additions and deletions to be performed on an enabled table without interruption.

Data definition commands

Delete a column family 'uni' from a table 'student'
Add a column family 'university' to a table student and allow for 5 versions in each cell in the column family
Increase a number of allowed versions in a column family 'personal'to 3

HBase Operations

Outline

HBase shell
Data definition commands
Data manipulation commands
HBase Java API

HBase Data Manipulation Commands

count Returns the number of rows in a table.

put Inserts a new cell value or updates an existing one for a specific row, column family, and column qualifier.

get Retrieves all or specific cells for a single row key.

delete Deletes a specific cell (a single version of data) in a row.

delete_all Deletes all cells for a specified row or all cells in a column family for a row.

truncate Disables, drops, and re-creates a table, effectively removing all data quickly while keeping the table structure.

scan Retrieves data by iterating over multiple rows, optionally starting and stopping at specific row keys.

Explanation of the put Command Examples

The put command is used to write data into an HBase table. Its basic syntax in the HBase shell is:

put ’table_name’, ’row_key’, ’column_family:column_qualifier’, ’value’

The examples demonstrate how to build a single row of data for a student with the row key '007' in the table named 'student' by inserting values into different columns within the 'personal' column family.

Example Breakdown

put 'student','007','personal:first-name','James'

Table Name: student

Row Key: '007' (This uniquely identifies the row)

Column: 'personal:first-name' (The column family is personal, and the column qualifier is first-name)

Value: 'James'

Result: Puts the value 'James' into the first-name column of the personal column family for the row identified by '007'

put 'student','007','personal:last-name','Bond'

Table Name: student

Row Key: '007'

Column: 'personal:last-name'

Value: 'Bond'

Result: Puts the value 'Bond' into the last-name column of the personal column family for the same row '007'.

put 'student','007','personal:dob','01-OCT-1960'

Table Name: student

Row Key: '007'

Column: 'personal:dob'

Value: '01-OCT-1960'

Result: Puts the value '01-OCT-1960' into the dob column of the personal column family for the same row '007'.

These three put operations collectively create a single, rich row of data for the user '007' in the 'student' table.

Data Manipulation commands

In Hbase, a set of data manipulation commands includes: count, put, get, delete, delete_all, truncate, scan
Put a value 'James' into a cell in a column family 'personal', qualification 'first-name', row key '007',
Put a value 'Bond'into a cell in a column family 'personal', qualification 'last-name', row key '007'
Put a value '01-OCT-1960'into a cell in a column family 'personal', qualification dob', row key '007',

The scan command retrieves data across multiple rows in the table. When used without filters, it iterates through all rows and columns of the specified table ('student') and outputs their contents. It is the equivalent of a full table read.

2. Put a Value (Insert/Update)

Put a value '02-OCT-1960' as the second version into a cell in a column family 'personal', qualification 'dob', row key '007' put 'student','007','personal:dob','02-OCT-1960'

The put command inserts a new cell value or updates an existing one.

'student': The table name.

'007': The row key, which uniquely identifies the row.

'personal:dob': The column, composed of the column family (personal) and the column qualifier (dob)

'02-OCT-1960': The value being stored.

Note on "Second Version": Without specifying an explicit timestamp, HBase assigns the current server time as the version ID. This value becomes the newest version for this cell, regardless of how many previous versions exist. To explicitly put a value as the "second version," you'd need to provide a timestamp older than the current newest version but newer than the third newest version.

3. Get Specific Cell Versions for One Row

Description Command

Get no more than 5 versions of a cell 'dob' in a column family 'personal' from a row '007' in a table 'student' get 'student','007',{COLUMN=>'personal:dob',VERSIONS=>5}

The get command is used to retrieve data for a single, specific row ('007'). The options within the braces filter the results:

COLUMN=>'personal:dob': Specifies the exact column to retrieve.

VERSIONS=>5: Instructs HBase to return up to the 5 most recent versions (identified by their timestamps) of the data stored in that single cell.

4. Scan Specific Column Versions Across the Table

Description Command

Get no more than 5 versions of a cell 'dob' in a column family 'personal', from a table 'student' scan 'student',{COLUMN=>'personal:dob',VERSIONS=>5}

Similar to the first command, the scan command iterates across all rows of the table ('student'). The options restrict the output:

COLUMN=>'personal:dob': Ensures that only this specific column is retrieved from each row.

VERSIONS=>5: For the specified column in every row returned by the scan, it retrieves up to the 5 most recent versions of the value.

Data Manipulation commands

List the contents of a table 'student'
Put a value '02-OCT-1960' as the second version into a cell in a column family 'personal', qualification dob', row key '007',
Get no more than 5 versions of a cell 'dob'in a column family 'personal'from a row '007'in a table 'student'
Get no more than 5 versions of a cell 'dob' in a column family 'personal', from a table 'student'

Get All Column Families in a Row

Get all column families in a row '666' in a table 'student' get 'student','666'

The get command, when used with just the table name ('student') and the row key ('666'), retrieves all cells (data) associated with that row. This includes all column families and their respective columns (qualifiers) along with the latest version of the value for each cell.

2. Get All Columns in a Specific Column Family (with Versions)

Get no more than 5 versions of values from all cells in a column family 'grade' in a row '666' in a table 'student' get 'student','666',{COLUMN=>'grade',VERSIONS=>5}

This command targets the single row '666' but uses options to filter the output:

COLUMN=>'grade': Specifies that only data from the entire column family named 'grade' should be returned.

VERSIONS=>5: For every cell found within the 'grade' column family, it retrieves up to the 5 most recent versions of the cell's value.

3. Get a Single Cell (Specific Column and Family, with Versions)

Get no more than 5 versions of values from a cell 'CSCI235' in a column family 'grade' in a row '666' in a table 'student' get 'student','666',{COLUMN=>'grade:CSCI235',VERSIONS=>5}

This is the most specific get operation. It targets a single cell:

The row key is '666'.

COLUMN=>'grade:CSCI235': Specifies a single column, where 'grade' is the column family and 'CSCI235' is the column qualifier (e.g., a course grade).

VERSIONS=>5: Retrieves up to the 5 most recent versions of the value stored only in the grade:CSCI235 cell.

4. Get a Specific Cell with Version History (Corrected Syntax from Previous Examples)

Get no more than 5 versions of values from a cell 'dob' in a column family 'personal' in a row '007' in a table 'student' (Note: The description has column family 'grade' but the command uses 'personal:dob') get 'student','007',{COLUMN=>'personal:dob',VERSIONS=>5}

This final example seems to be a slight variation or continuation of a previous set of commands, using a different row key ('007') and column family ('personal'):

The row key is '007'.

COLUMN=>'personal:dob': Specifies a single column: the column family is 'personal' and the qualifier is 'dob' (date of birth).

VERSIONS=>5: Retrieves up to the 5 most recent versions of the value stored in the personal:dob cell for row '007'.

Data Manipulation commands

Get all column families in a row '666'in a table 'student'
Get no more than 5 versions of values from all cells in a column family 'grade' in a row '666' in a table 'student'
Get no more than 5 versions of values from a cell 'CSCI235'in a column family 'grade'in a row '666' in a table 'student'
Get no more than 5 versions of values from a cell 'dob'in a column family 'grade'in a row '666'in a table 'student'

HBase Shell Commands Explained 🧑‍

Count Total Number of Rows

Command: count 'student'

Purpose: This command is used to count the total number of rows in the specified table, which in this case is 'student'. It essentially iterates through the rows and returns the final count.

Get Entire Table (One Version Per Cell)

Command: scan 'student'

Purpose: The scan command is used to retrieve data from a table. When used without any additional parameters (like columns or versions), it fetches all cells (data) for all rows in the table 'student'.

Default Behavior: By default, it returns only the most recent version (timestamp) of the data for each cell.

Get Entire Table (At Most 5 Versions Per Cell)

Command: scan 'student', {VERSIONS=>5}

Purpose: This command still retrieves all data from the table 'student', but the {VERSIONS=>5} parameter modifies the output.

VERSIONS Parameter: It specifies the maximum number of historical versions (timestamped values) to return for each cell. In this case, it will show up to 5 versions of data for every cell in the table.

Get Specific Column and Multiple Versions

Command: scan 'student', {COLUMNS=>'personal:dob', VERSIONS=>5}

Purpose: This command is a more refined scan that targets specific data within the table 'student'.

COLUMNS Parameter: This parameter limits the data retrieval to a specific column. 'personal:dob' means it will only fetch the cells belonging to the column named dob (date of birth) within the column family named personal.

VERSIONS Parameter: Similar to the previous example, this ensures that the scan returns up to 5 historical versions of the data for the personal:dob cell for every row in the table.

Data Manipulation commands

Count total number of rows in a table 'student'
Get entire table 'student', one version per cell
Get entire table 'student', at most 5 versions per cell
Get all cells 'dob' from in a column family 'personal'from entire table'student', at most 5 versions per cell

Scan by Multiple Column Families

Command: scan 'student',{COLUMNS=>['personal','university']}

Purpose: This command retrieves all data from the table 'student', but restricts the output to only the cells belonging to the specified column families.

COLUMNS Parameter: When given a list of column family names (e.g., ['personal','university']), it instructs HBase to return all columns within the personal column family and all columns within the university column family for every row.

Output: It will return the most recent version of data for every cell under the 'personal' and 'university' column families.

Scan with Time Range and Versions

Command: scan 'student',{COLUMNS=>'personal:dob',TIMERANGE=>[1,1502609828830],VERSIONS=>5}

Purpose: This command retrieves up to 5 historical versions of the 'date of birth' data, but only those versions that fall within a specific time window.

COLUMNS Parameter: Targets the specific column dob within the column family personal.

TIMERANGE Parameter: This is crucial. It defines a timestamp range (in milliseconds since the Unix epoch) for the data versions to be included in the scan. The format is [minTimestamp, maxTimestamp]. Only cell versions whose timestamps fall in this range are returned.

VERSIONS Parameter: Specifies that among the versions that fall within the TIMERANGE, a maximum of 5 should be returned per cell.

Scan with Filter for Time Range (Alternative Method)

Command: scan 'student',{COLUMNS=>'personal:dob',FILTER=>"TimestampsFilter(1,1502609828830)",VERSIONS=>5}

Purpose: This command achieves the same result as the previous example but uses a Filter string instead of the dedicated TIMERANGE parameter. Filters provide a more flexible way to specify complex data selection criteria.

COLUMNS and VERSIONS: Same as the previous command—targets personal:dob and requests up to 5 versions.

FILTER Parameter: The filter string "TimestampsFilter(1,1502609828830)" is a specialized HBase filter that effectively implements the same timestamp range restriction as the TIMERANGE parameter. It limits the retrieved versions to those having a timestamp between the specified minimum (1) and maximum (1502609828830).

Data Manipulation commands

Get all cells from the column families 'personal' and 'university' from entire table 'student'
Get at most 5 versions of cells 'dob' with timestamps in a range [1,1502609828830], from a column family 'personal' from entire table 'student'
Get at most 5 versions of cells 'dob' with timestamps in a range [1,1502609828830], from a column family 'personal' from entire table 'student'

Scan with Qualifier Filter (Column Name)

Command: scan 'student',{FILTER=>"QualifierFilter(>=,'binary:f')"}

Purpose: This command retrieves all cells from the table 'student' whose column name (Qualifier) is lexicographically greater than or equal to ('$>= $') the binary value of the string 'f'.

QualifierFilter: Filters based on the column name (the part after the colon, e.g., 'dob', 'name', 'city').

>=,'binary:f': The operator is 'greater than or equal to', and the comparator specifies the value to check against. The prefix binary: indicates that the value 'f' should be compared as a raw sequence of bytes.

Scan with Value Filter (Cell Value)

Command: scan 'student',{FILTER=>"ValueFilter(>=,'binary:J')"}

Purpose: This command retrieves all rows from the table 'student' that contain at least one cell whose value is lexicographically greater than or equal to ('$>= $') the binary value of the string 'J'.

ValueFilter: Filters based on the actual data stored inside the cell.

>=,'binary:J': It checks if any cell's value in a row meets the condition. If any cell in a row matches, the entire row is returned (unless specific columns are requested).

Scan with Value Range Filter (Combined Values)

Command: scan 'student',{FILTER=>"ValueFilter(>=,'binary:J') AND ValueFilter(<=,'binary:K')"}

Purpose: This command retrieves all rows from the table 'student' that contain at least one cell whose value falls within the inclusive range of ['J', 'K'].

Chained Filters: This shows how to combine multiple filters using the logical AND operator to create a range constraint.

The row is returned only if it satisfies both conditions: containing a cell with a value ≥’J’ AND containing a cell with a value ≤’K’ (Note: a single cell must satisfy both conditions to return the row in this specific logical construction). This effectively creates a range check.

Scan with Combined Qualifier and Value Filters

Command: scan 'student',{COLUMNS=>'personal:dob',FILTER=>"QualifierFilter(=,'binary:dob') AND ValueFilter(=,'binary:02-OCT-1960')"}

Purpose: This command performs a highly specific lookup: it returns the value of the 'dob' cell only for rows in the 'student' table where the 'dob' cell's value is exactly equal to '02-OCT-1960'.

COLUMNS=>'personal:dob': This is a projection, ensuring the output only shows the value of the personal:dob cell.

Chained Filters:

QualifierFilter(=,'binary:dob'): This is redundant because the COLUMNS parameter already targets the dob qualifier, but it's used here to demonstrate filtering rows based on a specific column's existence/name.

ValueFilter(=,'binary:02-OCT-1960'): This is the primary filter that restricts the rows returned to only those where the cell under the relevant column (dob) has the exact value '02-OCT-1960'.

Data Manipulation commands

Get all cells whose name is >= than 'f' in a table 'student'

scan 'student',{FILTER=>"QualifierFilter(>=,'binary:f')"}

Get all rows from a table 'student' that have value of a cell >= than 'J'

Get all rows from a table 'student'that have value of a cell in a range ['J','K']

scan 'student',{FILTER=>"ValueFilter(>=,'binary:J') AND 
                ValueFilter(<=,'binary:K')"}

Get all values of cells 'dob' in a column family 'personal'from rows in a table 'student'where a cell 'dob'has a value '02-OCT-1960'

scan 'student',{COLUMNS=>'personal:dob',FILTER=>
                "QualifierFilter(=,'binary:dob') AND 
				        ValueFilter(=,'binary:02-OCT-1960')"}

Delete a Specific Cell

Command: delete 'student','666','grade:CSCI235'

Purpose: This command is used to delete the most recent version of a specific cell from the table.

delete: The core command for cell-level deletion.

'student': The name of the table to operate on.

'666': The Row Key that uniquely identifies the row containing the cell.

'grade:CSCI235': The Column Qualifier. This specifies the column to delete, where grade is the Column Family and CSCI235 is the specific Column Name (Qualifier).

Note: This command only deletes the most recent version of the cell unless a timestamp is also provided. To delete all versions of a cell, you would typically use deleteall with the column qualifier.

Delete an Entire Row

Command: deleteall 'student', '007'

Purpose: This command is used to delete an entire row, including all cells and all versions of those cells, from the specified table.

Deleteall: The command specifically designed for deleting all data associated with a row or a column.

'student': The name of the table.

'007': The Row Key identifying the specific row to be completely removed from the table.

Effect: After this command executes, the row with key '007' will no longer exist in the 'student' table.

Data Manipulation commands

Delete a cell 'CSCI235'from a column family 'student' in a row '666' in a table 'student'
Delete entire row '007' from a table 'student'

HBase Operations

Outline

HBase shell
Data definition commands
Data manipulation commands
HBase Java API

HBase Table Creation Java API Explanation

1. Imports

The necessary classes are imported to interact with the HBase configuration and administrative functions:

org.apache.hadoop.conf.Configuration: Used to manage the Hadoop and HBase cluster configuration settings.

org.apache.hadoop.hbase.HBaseConfiguration: A utility class to create a configuration object specifically for HBase.

org.apache.hadoop.hbase.HColumnDescriptor: Describes a Column Family for a table.

org.apache.hadoop.hbase.HTableDescriptor: Describes an entire Table.

org.apache.hadoop.hbase.TableName: A wrapper class for table names.

org.apache.hadoop.hbase.client.HBaseAdmin: The class used for administrative operations like creating, dropping, or enabling tables.

2. Configuration and Administration

Configuration conf = HBaseConfiguration.create();

HBaseAdmin admin = new HBaseAdmin(conf);

Configuration conf = HBaseConfiguration.create();: This line initializes the configuration object. It automatically loads cluster settings from configuration files (like hbase-site.xml) found in the classpath, allowing the client to connect to the HBase master.

HBaseAdmin admin = new HBaseAdmin(conf);: An instance of HBaseAdmin is created. This object is the client's gateway to the HBase cluster's administrative functions.

3. Table and Column Family Definition

HTableDescriptor tableDescriptor = new HTableDescriptor(TableName.valueOf("my-table"));

tableDescriptor.addFamily(new HColumnDescriptor("Address"));

tableDescriptor.addFamily(new HColumnDescriptor("Name"));

HTableDescriptor: A new table description object is instantiated for the table named "my-table". This object holds the metadata for the new table.

addFamily(new HColumnDescriptor(...)): This is where the table's schema is defined.

It creates a new column family named "Address" and adds it to the table descriptor.

It creates a second column family named "Name" and adds it to the table descriptor.

4. Table Creation and Verification

admin.createTable(tableDescriptor);

boolean tableAvailable = admin.isTableAvailable("my-table");

System.out.println("tableAvailable = " + tableAvailable);

admin.createTable(tableDescriptor);: This is the DDL command that sends the table definition to the HBase Master, which then initiates the physical creation of the table on the RegionServers.

admin.isTableAvailable("my-table");: Checks the HBase Master to see if the newly created table is accessible and ready for use.

System.out.println(...): Prints the boolean result to the console to confirm the success of the operation.

HBase Java API

HBase Java Application Program Interface allows to access HBase tables from programs written in Java
The client APIs provide both data definition and data manipulation features

Creating a table 'my-table' and column families 'Address' and 'Name'

import org.apache.hadoop.conf.Configuration; 
import org.apache.hadoop.hbase.HBaseConfiguration; 
import org.apache.hadoop.hbase.HColumnDescriptor; 
import org.apache.hadoop.hbase.HTableDescriptor; 
import org.apache.hadoop.hbase.TableName; 
import org.apache.hadoop.hbase.client.HBaseAdmin;

public class CreateTable { 
  public static void main(String[] args) throws Exception { 
    Configuration conf = HBaseConfiguration.create(); 
    HBaseAdmin admin = new HBaseAdmin(conf); 
    HTableDescriptor tableDescriptor = new HTableDescriptor(TableName.valueOf("my-table")); 
    tableDescriptor.addFamily(new HColumnDescriptor("Address")); 
    tableDescriptor.addFamily(new HColumnDescriptor("Name")); 
    admin.createTable(tableDescriptor); 
    boolean tableAvailable = admin.isTableAvailable("my-table"); 
    System.out.println("tableAvailable = " + tableAvailable); } }

Inserting Data into HBase with Java API

The PutRow class constructs a single row of data and writes it to the HBase table.

1. Setup and Connection

Configuration conf = HBaseConfiguration.create();

HTable table = new HTable(conf, "my-table");

Configuration conf = HBaseConfiguration.create();: Initializes the configuration to connect to the HBase cluster.

HTable table = new HTable(conf, "my-table");: Establishes a connection (client-side access object) to the specific table named "my-table". This object will be used to perform data operations.

2. Creating the Put Operation

Put put = new Put(Bytes.toBytes("007"));

Put put = new Put(...): Creates a new Put object, which represents all the cells to be written to a single row.

Bytes.toBytes("007"): The constructor takes the Row Key. Here, the row key is set to "007". The Bytes.toBytes() utility is essential because HBase stores all data (row keys, column families, qualifiers, and cell values) as raw byte arrays.

Adding Cells to the Row

The code then adds four individual cells to the put object. The structure for adding a cell is generally put.add(ColumnFamily, Qualifier, Value).

Code Line Column Family Column Qualifier Cell Value

put.add(Bytes.toBytes("Address"), Bytes.toBytes("City"), Bytes.toBytes("Dapto")); Address City Dapto

put.add(Bytes.toBytes("Address"), Bytes.toBytes("Street"), Bytes.toBytes("Ellenborough")); Address Street Ellenborough

put.add(Bytes.toBytes("Name"), Bytes.toBytes("First"), Bytes.toBytes("James")); Name First James

put.add(Bytes.toBytes("Name"), Bytes.toBytes("Last"), Bytes.toBytes("Bond")); Name Last Bond

4. Executing and Closing

table.put(put);

table.flushCommits();

table.close();

HBase Java API

Inserting data into HBase table 'my-table'

public class PutRow { 
  public static void main(String[] args) throws Exception { 
    Configuration conf = HBaseConfiguration.create(); 
    HTable table = new HTable(conf, "my-table"); 
    Put put = new Put(Bytes.toBytes("007")); 
    put.add(Bytes.toBytes("Address"),Bytes.toBytes("City"),Bytes.toBytes("Dapto")); 
    put.add(Bytes.toBytes("Address"),Bytes.toBytes("Street"),Bytes.toBytes("Ellenborough")); 
    put.add(Bytes.toBytes("Name"),Bytes.toBytes("First"),Bytes.toBytes("James")); 
    put.add(Bytes.toBytes("Name"),Bytes.toBytes("Last"),Bytes.toBytes("Bond")); 
    table.put(put); 
    table.flushCommits(); 
    table.close(); 
  } 
}

The provided code performs the following actions:

Configuration and Table Setup:

Configuration conf = HBaseConfiguration.create(); creates the necessary HBase configuration.

HTable table = new HTable(conf, "my-table"); instantiates an HTable object representing the HBase table named 'my-table'.

Defining the Get Request:

Get get = new Get(Bytes.toBytes("007")); creates a Get object targeting the row with the row key '007'. The row key must be converted to a byte array using Bytes.toBytes().

get.setMaxVersions(3); specifies that for any requested cell, up to the last 3 versions (timestamps) of the value should be returned.

get.addFamily(Bytes.toBytes("Address")); includes all columns belonging to the column family named 'Address' in the retrieval request.

get.addColumn(Bytes.toBytes("Name"), Bytes.toBytes("First")); explicitly includes the column Name:First (family Name, qualifier First).

get.addColumn(Bytes.toBytes("Name"), Bytes.toBytes("Last")); explicitly includes the column Name:Last (family Name, qualifier Last).

Executing the Get and Getting the Result:

Result result = table.get(get); executes the retrieval request against the table. The data fetched for row '007', based on the criteria defined in the get object, is stored in a Result object.

String row = Bytes.toString(result.getRow()); retrieves the row key from the Result object and converts it back from bytes to a String (which will be "007").

HBase Java API

Getting data from HBase table 'my-table'

import java.util.Map;
import java.util.NavigableMap

public class GetRow {
    public static void main(String[] args) throws Exception {
        Configuration conf = HBaseConfiguration.create();
        HTable table = new HTable(conf, "my-table");
        Get get = new Get(Bytes.toBytes("007"));
        get.setMaxVersions(3);
        get.addFamily(Bytes.toBytes("Address"));
        get.addColumn(Bytes.toBytes("Name"), Bytes.toBytes("First"));
        get.addColumn(Bytes.toBytes("Name"), Bytes.toBytes("Last"));

// Get a specific value
        Result result = table.get(get); 
        String row = Bytes.toString(result.getRow());

This code snippet demonstrates how to extract and print specific values from the Result object that was fetched in the previous HBase Get operation. It relies on the columns you requested being present in the Result.

Extracting Values from the Result

The code uses the result.getValue() method repeatedly to retrieve the data for specific cells.

Key Method: result.getValue()

The getValue() method signature is: byte[] getValue(byte[] family, byte[] qualifier)

result: This is the Result object returned by the table.get(get) call, which holds all the fetched data for row '007'.

getValue(...): This method searches the Result object for the latest version of the value associated with the specified column family and column qualifier.

Note: Because it only fetches the latest version, it ignores the get.setMaxVersions(3) setting from the previous code, which fetched up to three versions for the entire row. To access older versions, you'd use methods like result.getMap() or result.getColumnCells().

Bytes.toBytes("Address") / Bytes.toBytes("City"): The column family and column qualifier must be provided as byte arrays, just like when defining the Get request.

Bytes.toString(...): Since getValue() returns the data as a raw byte array, Bytes.toString() converts it back into a readable Java String for printing.

HBase Java API

Getting data from HBase table 'my-table'

	     
   String specificValue = Bytes.toString(result.getValue(Bytes.toBytes("Address"),
                                         Bytes.toBytes("City")));
   System.out.println("Latest Address:City is: " + specificValue);
          specificValue = Bytes.toString(result.getValue(Bytes.toBytes("Address"),
	                                 Bytes.toBytes("Street")));
   System.out.println("Latest Address:Street is: " + specificValue);
          specificValue = Bytes.toString(result.getValue(Bytes.toBytes("Name"),
	                                 Bytes.toBytes("First")));
   System.out.println("Latest Name:First is: " + specificValue);
          specificValue = Bytes.toString(result.getValue(Bytes.toBytes("Name"),
	                                 Bytes.toBytes("Last")));
   System.out.println("Latest Name:Last is: " + specificValue)

Traversing the Entire Row Result

The key to traversing the full result is using the result.getMap() method. This method returns a deeply nested NavigableMap that reflects the hierarchical structure of data in HBase: Family → Qualifier → Timestamp → Value.

Data Structure of result.getMap()

The structure returned by result.getMap() is: NavigableMap>>

Let's break down the iteration steps:

1. The Row Key

System.out.println("Row key: " + row);

First, the code prints the Row Key (which is "007" in this example) to identify the data being processed.

2. Getting the Top-Level Map (Families)

NavigableMap>> map = result.getMap();

for (Map.Entry>> navigableMapEntry : map.entrySet()) {

String family = Bytes.toString(navigableMapEntry.getKey());

System.out.println("\t" + family);

result.getMap() retrieves the entire content as a map.

The outer loop iterates through the Column Families (e.g., "Address", "Name").

navigableMapEntry.getKey() gives the family name (as bytes), which is converted and printed.

3. Iterating Qualifiers within a Family

NavigableMap> familyContents = navigableMapEntry.getValue();

for (Map.Entry> mapEntry : familyContents.entrySet()) {

String qualifier = Bytes.toString(mapEntry.getKey());

System.out.println("\t\t" + qualifier);

navigableMapEntry.getValue() provides the map containing all Qualifiers (columns) within the current family.

The middle loop iterates through the qualifiers (e.g., "City", "Street" for family "Address").

mapEntry.getKey() gives the qualifier name (as bytes), which is converted and printed.

4. Iterating Versions (Timestamps and Values)

NavigableMap qualifierContents = mapEntry.getValue();

for (Map.Entry entry : qualifierContents.entrySet()) {

Long timestamp = entry.getKey();

String value = Bytes.toString(entry.getValue());

System.out.printf("\t\t\t%s, %d\n", value, timestamp);

}

mapEntry.getValue() provides the map containing all versions for the current column.

The innermost loop iterates through the versions (cells) of the column. This is where the get.setMaxVersions(3) setting from the previous code block becomes relevant, as it dictates how many entries this loop runs.

entry.getKey() is the timestamp (a Long) for that specific version.

entry.getValue() is the column value (as bytes), which is converted and printed along with its timestamp.

5. Cleanup

table.close();

Finally, the code closes the HTable instance to release any associated resources, which is a crucial practice for preventing connection leaks.

This triple-nested iteration ensures that every piece of requested data (cell) in the Result object is processed, including all requested versions.

Would you like to know how to perform a Scan operation, which is used to retrieve multiple rows from an HBase table?

HBase Java API

// Traverse entire returned row
        System.out.println("Row key: " + row);
        NavigableMap>> map = result.getMap();
        for (Map.Entry>> navigableMapEntry : map.entrySet()) {
            String family = Bytes.toString(navigableMapEntry.getKey());
            System.out.println("\t" + family);
            NavigableMap> familyContents = navigableMapEntry.getValue();
            for (Map.Entry> mapEntry : familyContents.entrySet()) {
                String qualifier = Bytes.toString(mapEntry.getKey());
                System.out.println("\t\t" + qualifier);
                NavigableMap qualifierContents = mapEntry.getValue();
                for (Map.Entry entry : qualifierContents.entrySet()) {
                    Long timestamp = entry.getKey();
                    String value = Bytes.toString(entry.getValue());
                    System.out.printf("\t\t\t%s, %d\n", value, timestamp);
                }
            }
        }
        table.close();
    }
}

References

HBase shell commands, https://url.au.m.mimecastprotect.com/s/l9LmCANpDDtNNllqji9i1uGQ1Xq?domain=learnhbase.wordpress.com
HBase shell and General commands, https://url.au.m.mimecastprotect.com/s/SBTECBNqBBt77RR2vFjs3u2WHxw?domain=guru99.com
HBase Java API, https://url.au.m.mimecastprotect.com/s/E-dcCD1vkkT55JJGXsltZujFy2S?domain=dzone.com
Kerzner M., Maniyam S., HBase Design Patterns, Packt Publishing 2014 (Available from UoW Library)
Jiang, Y. HBase Adminstration Cookbook, Pack Publishing, 2012 (Available from UoW Library)
Dimiduk N., Khurana A., HBase in Action, Mannig Publishers, 2013
Spaggiari J-M., O'Dell K., Architecting HBase Applications, O'Reilly, 2016