Hbase 简明教程
HBase - Overview
自 1970 年以来,RDBMS 一直是与数据存储和维护相关问题的一个解决方案。随着大数据时代的到来,公司意识到处理大数据的优势并开始选择 Hadoop 等解决方案。
Hadoop 使用分布式文件系统存储大数据,并使用 MapReduce 处理大数据。Hadoop 擅长存储和处理任意、半结构化甚至非结构化等各种格式的巨量数据。
Limitations of Hadoop
Hadoop 只可以执行批处理,并且只能顺序访问数据。这意味着即使是最简单的作业也必须搜索整个数据集。
处理后的巨型数据集会产生另一个巨型数据集,并且也应该按顺序进行处理。此时,需要一个新的解决方案,以便在单个时间单位(随机访问)内访问数据的任何点。
What is HBase?
HBase 是构建在 Hadoop 文件系统之上的分布式面向列数据库。它是一个开源项目,且可水平扩展。
HBase 是一种数据模型,它类似于 Google 的大型表格,旨在为大量结构化数据提供快速随机访问。它利用了 Hadoop 文件系统 (HDFS) 提供的容错功能。
它是 Hadoop 生态系统的一部分,它提供了对 Hadoop 文件系统中数据的随机实时读/写访问。
人们可以通过 HDFS 直接或通过 HBase 将数据存储在 HDFS 中。数据使用者使用 HBase 以随机方式读取/访问 HDFS 中的数据。HBase 位于 Hadoop 文件系统之上,并提供读写访问。
HBase and HDFS
HDFS |
HBase |
HDFS 是一个分布式文件系统,适用于存储大文件。 |
HBase 是构建在 HDFS 之上的一个数据库。 |
HDFS 不支持快速查找各条记录。 |
HBase 能够对更大的表进行快速查找。 |
它提供了高延迟批处理;没有批处理的概念。 |
它提供了对数十亿条记录的单行低延迟访问(随机访问)。 |
它只能提供对数据的顺序访问。 |
HBase 在内部使用哈希表并提供随机访问,并将其数据存储在已编制索引的 HDFS 文件中以进行快速查找。 |
Storage Mechanism in HBase
HBase 是一个 column-oriented database ,其中的表按行排序。表模式仅定义列族,即键值对。一个表可以有许多列族,并且每个列族可以有任意数量的列。后续列值将连续存储在磁盘上。表的每个单元格值都带有一个时间戳。简而言之,在 HBase 中:
-
表是行的集合。
-
行是列族的集合。
-
列族是列的集合。
-
列是键值对的集合。
下面给出了 HBase 中表的示例模式。
Rowid |
Column Family |
Column Family |
Column Family |
Column Family |
col1 |
col2 |
col3 |
col1 |
col2 |
col3 |
col1 |
col2 |
col3 |
col1 |
col2 |
col3 |
1 |
||
2 |
||||
3 |
||||
Column Oriented and Row Oriented
面向列的数据库是将数据表存储为数据列段(而不是数据行)的数据库。简而言之,它们将具有列族。
Row-Oriented Database |
Column-Oriented Database |
它适合在线事务处理 (OLTP)。 |
它适合在线分析处理 (OLAP)。 |
此类数据库是针对少量行和列设计的。 |
面向列的数据库是针对大表设计的。 |
下图显示了面向列的数据库中的列族:
HBase and RDBMS
HBase |
RDBMS |
HBase 是无模式的,它没有固定列模式的概念;仅定义列族。 |
RDBMS 由其模式管理,模式描述了表的所有结构。 |
它专为宽表而构建。HBase 可水平扩展。 |
它很薄,专为小表而构建。难以扩展。 |
HBase 中没有事务。 |
RDBMS is transactional. |
It has de-normalized data. |
它将具有标准化数据。 |
它适用于半结构化数据以及结构化数据。 |
它适用于结构化数据。 |
Features of HBase
-
HBase is linearly scalable.
-
它具有自动故障支持。
-
它提供了一致的读和写操作。
-
它作为源和目标与 Hadoop 集成。
-
它具有用于客户端的简单 Java API。
-
它提供跨集群的数据复制。
Where to Use HBase
-
Apache HBase 用于随机、实时地读/写访问大数据。
-
它在商品硬件集群之上托管极大的表。
-
Apache HBase 是非关系型数据库,其模型参考了 Google 的 Bigtable。Bigtable 在 Google 文件系统上执行操作,同样 Apache HBase 也在 Hadoop 和 HDFS 之上工作。
Applications of HBase
-
在需要编写重量级应用程序时,它会被使用。
-
每当我们需要为可用数据提供快速随机访问时,HBase 就会被使用。
-
Facebook、Twitter、Yahoo 和 Adobe 等公司在内部使用 HBase。
HBase History
Year |
Event |
Nov 2006 |
Google 发表了关于 BigTable 的论文。 |
Feb 2007 |
初始 HBase 原型创建为 Hadoop 贡献。 |
Oct 2007 |
第一个可用的 HBase 与 Hadoop 0.15.0 同时发布。 |
Jan 2008 |
HBase 成为 Hadoop 子项目。 |
Oct 2008 |
HBase 0.18.1 was released. |
Jan 2009 |
HBase 0.19.0 was released. |
Sept 2009 |
HBase 0.20.0 was released. |
May 2010 |
HBase 成为 Apache 顶级项目。 |
HBase - Architecture
在 HBase 中,表格被划分为区域并由区域服务器提供服务。区域按列族垂直划分为“存储”。存储在 HDFS 中作为文件保存。下面显示了 HBase 的体系结构。
Note: “存储”一词用于区域以解释存储结构。
HBase 有三个主要组件:客户端库、主服务器和区域服务器。可以根据需要添加或删除区域服务器。
MasterServer
主服务器 -
-
将区域分配给区域服务器并为此任务获得 Apache ZooKeeper 的帮助。
-
处理跨区域服务器的区域负载平衡。它卸载繁忙的服务器并将区域转移到占用较少的服务器。
-
通过协商负载平衡来维护集群状态。
-
负责模式更改和创建表格和列系列等其他元数据操作。
HBase - Installation
本章节解释了 HBase 的安装和初始配置方式。要在 HBase 中继续操作,需要用到 Java 和 Hadoop,因此您必须在系统中下载并安装 Java 和 Hadoop。
Pre-Installation Setup
在将 Hadoop 安装到 Linux 环境中之前,我们需要使用 ssh (安全外壳)设置 Linux。按照下面给出的步骤设置 Linux 环境。
Creating a User
首先,建议为 Hadoop 创建一个单独的用户,从而将 Hadoop 文件系统从 Unix 文件系统中分离出来。请按照以下步骤创建用户。
-
使用命令“su”打开 root。
-
使用命令“useradd username”从 root 帐户创建用户。
-
现在可以使用命令“su username”打开一个现有用户帐户。
打开 Linux 终端并输入以下命令以创建用户。
$ su
password:
# useradd hadoop
# passwd hadoop
New passwd:
Retype new passwd
SSH Setup and Key Generation
需要设置 SSH 以对集群执行不同的操作,例如启动、停止和分布式守护进程 shell 操作。为了验证 Hadoop 的不同用户,需要为 Hadoop 用户提供公私密钥对,并与不同用户共享该密钥对。
使用 SSH 生成的以下命令用于生成密钥值对。将 id_rsa.pub 中的公钥复制到 authorized_keys,然后分别为 authorized_keys 文件提供所有者、读取和写入权限。
$ ssh-keygen -t rsa
$ cat ~/.ssh/id_rsa.pub >> ~/.ssh/authorized_keys
$ chmod 0600 ~/.ssh/authorized_keys
Installing Java
Java 是 Hadoop 和 HBase 的主要前提条件。首先,您应该使用“java -version”验证系统中是否存在 Java。“java -version”的语法如下所示。
$ java -version
如果一切正常,它会给您以下输出结果。
java version "1.7.0_71"
Java(TM) SE Runtime Environment (build 1.7.0_71-b13)
Java HotSpot(TM) Client VM (build 25.0-b02, mixed mode)
如果您的系统中未安装 java,请按照以下步骤安装 java。
Step 1
通过访问以下链接 Oracle Java 下载 Java(JDK <最新版本>- X64.tar.gz)。
然后 jdk-7u71-linux-x64.tar.gz 将下载到您的系统中。
Step 2
通常,您将在“下载”文件夹中找到下载的 java 文件。使用以下命令对其进行验证并解压缩 jdk-7u71-linux-x64.gz 文件。
$ cd Downloads/
$ ls
jdk-7u71-linux-x64.gz
$ tar zxf jdk-7u71-linux-x64.gz
$ ls
jdk1.7.0_71 jdk-7u71-linux-x64.gz
Step 3
要向所有用户提供 Java,您必须将其移动到“/usr/local/”位置。打开 Root,然后键入以下命令。
$ su
password:
# mv jdk1.7.0_71 /usr/local/
# exit
Step 4
为设置 PATH 和 JAVA_HOME 变量,将以下命令添加到 ~/.bashrc 文件。
export JAVA_HOME=/usr/local/jdk1.7.0_71
export PATH= $PATH:$JAVA_HOME/bin
现在将所有更改应用到当前正在运行的系统中。
$ source ~/.bashrc
Step 5
使用以下命令配置 Java 替代项:
# alternatives --install /usr/bin/java java usr/local/java/bin/java 2
# alternatives --install /usr/bin/javac javac usr/local/java/bin/javac 2
# alternatives --install /usr/bin/jar jar usr/local/java/bin/jar 2
# alternatives --set java usr/local/java/bin/java
# alternatives --set javac usr/local/java/bin/javac
# alternatives --set jar usr/local/java/bin/jar
现在,根据以上说明,验证终端中的 java -version 命令。
Downloading Hadoop
安装 Java 后,必须安装 Hadoop。首先,使用“Hadoop version”命令(如下所示)验证是否存在 Hadoop。
hadoop version
如果一切正常,它会给您以下输出结果。
Hadoop 2.6.0
Compiled by jenkins on 2014-11-13T21:10Z
Compiled with protoc 2.5.0
From source with checksum 18e43357c8f927c0695f1e9522859d6a
This command was run using
/home/hadoop/hadoop/share/hadoop/common/hadoop-common-2.6.0.jar
如果系统无法找到 Hadoop,则在系统中下载 Hadoop。按照以下给出的命令操作。
使用以下命令从 Apache Software Foundation 下载并解压 hadoop-2.6.0 。
$ su
password:
# cd /usr/local
# wget http://mirrors.advancedhosters.com/apache/hadoop/common/hadoop-
2.6.0/hadoop-2.6.0-src.tar.gz
# tar xzf hadoop-2.6.0-src.tar.gz
# mv hadoop-2.6.0/* hadoop/
# exit
Installing Hadoop
以所需的任何模式安装 Hadoop。此处,我们在 pseudo 分布模式下演示 HBase 功能,因此在 pseudo 分布模式下安装 Hadoop。
以下步骤用于安装 Hadoop 2.4.1 。
Step 1 - Setting up Hadoop
您可以通过将以下命令追加到 ~/.bashrc 文件来设置 Hadoop 环境变量。
export HADOOP_HOME=/usr/local/hadoop
export HADOOP_MAPRED_HOME=$HADOOP_HOME
export HADOOP_COMMON_HOME=$HADOOP_HOME
export HADOOP_HDFS_HOME=$HADOOP_HOME
export YARN_HOME=$HADOOP_HOME
export HADOOP_COMMON_LIB_NATIVE_DIR=$HADOOP_HOME/lib/native
export PATH=$PATH:$HADOOP_HOME/sbin:$HADOOP_HOME/bin
export HADOOP_INSTALL=$HADOOP_HOME
现在将所有更改应用到当前正在运行的系统中。
$ source ~/.bashrc
Step 2 - Hadoop Configuration
可以在以下位置找到所有 Hadoop 配置文件:“$HADOOP_HOME/etc/hadoop”。需要根据 Hadoop 基础设施在这些配置文件中进行修改。
$ cd $HADOOP_HOME/etc/hadoop
为了在 Java 中开发 Hadoop 程序,必须在 hadoop-env.sh 文件中重置 Java 环境变量,方法是用系统中 Java 的位置替换 JAVA_HOME 值。
export JAVA_HOME=/usr/local/jdk1.7.0_71
你需要编辑以下文件来配置 Hadoop。
core-site.xml
core-site.xml 文件包含诸如 Hadoop 实例使用的端口号、分配给文件系统、数据存储内存限制和读/写缓冲区大小等信息。
打开 core-site.xml,并在 <configuration> 和 </configuration> 标记之间添加以下属性。
<configuration>
<property>
<name>fs.default.name</name>
<value>hdfs://localhost:9000</value>
</property>
</configuration>
hdfs-site.xml
hdfs-site.xml 文件包含诸如复制数据值、本地文件系统(打算存储 Hadoop 基础设施)的名称节点路径和数据节点路径等信息。
让我们假设以下数据。
dfs.replication (data replication value) = 1
(In the below given path /hadoop/ is the user name.
hadoopinfra/hdfs/namenode is the directory created by hdfs file system.)
namenode path = //home/hadoop/hadoopinfra/hdfs/namenode
(hadoopinfra/hdfs/datanode is the directory created by hdfs file system.)
datanode path = //home/hadoop/hadoopinfra/hdfs/datanode
打开该文件,并在 <configuration>、</configuration> 标记之间添加以下属性。
<configuration>
<property>
<name>dfs.replication</name >
<value>1</value>
</property>
<property>
<name>dfs.name.dir</name>
<value>file:///home/hadoop/hadoopinfra/hdfs/namenode</value>
</property>
<property>
<name>dfs.data.dir</name>
<value>file:///home/hadoop/hadoopinfra/hdfs/datanode</value>
</property>
</configuration>
Note: 在上述文件中,所有属性值都是用户定义的,可以根据 Hadoop 基础设施进行修改。
yarn-site.xml
此文件用于将 yarn 配置到 Hadoop。打开 yarn-site.xml 文件,并在该文件中的 <configuration$gt;、</configuration$gt; 标记之间添加以下属性。
<configuration>
<property>
<name>yarn.nodemanager.aux-services</name>
<value>mapreduce_shuffle</value>
</property>
</configuration>
mapred-site.xml
此文件用于指定我们正在使用哪种 MapReduce 框架。默认情况下,Hadoop 包含 yarn-site.xml 的模板。首先,需要使用以下命令将文件从 mapred-site.xml.template 复制到 mapred-site.xml 。
$ cp mapred-site.xml.template mapred-site.xml
打开 mapred-site.xml 文件,并在 <configuration> 和 </configuration> 标记之间添加以下属性。
<configuration>
<property>
<name>mapreduce.framework.name</name>
<value>yarn</value>
</property>
</configuration>
Verifying Hadoop Installation
以下步骤用于验证 Hadoop 安装。
Step 1 - Name Node Setup
使用命令 “hdfs namenode -format” 设置名称节点,如下所示。
$ cd ~
$ hdfs namenode -format
预期结果如下所示。
10/24/14 21:30:55 INFO namenode.NameNode: STARTUP_MSG:
/************************************************************
STARTUP_MSG: Starting NameNode
STARTUP_MSG: host = localhost/192.168.1.11
STARTUP_MSG: args = [-format]
STARTUP_MSG: version = 2.4.1
...
...
10/24/14 21:30:56 INFO common.Storage: Storage directory
/home/hadoop/hadoopinfra/hdfs/namenode has been successfully formatted.
10/24/14 21:30:56 INFO namenode.NNStorageRetentionManager: Going to
retain 1 images with txid >= 0
10/24/14 21:30:56 INFO util.ExitUtil: Exiting with status 0
10/24/14 21:30:56 INFO namenode.NameNode: SHUTDOWN_MSG:
/************************************************************
SHUTDOWN_MSG: Shutting down NameNode at localhost/192.168.1.11
************************************************************/
Step 2 - Verifying Hadoop dfs
以下命令用于启动 DFS。执行此命令将启动您的 Hadoop 文件系统。
$ start-dfs.sh
预期输出如下。
10/24/14 21:37:56
Starting namenodes on [localhost]
localhost: starting namenode, logging to /home/hadoop/hadoop-
2.4.1/logs/hadoop-hadoop-namenode-localhost.out
localhost: starting datanode, logging to /home/hadoop/hadoop-
2.4.1/logs/hadoop-hadoop-datanode-localhost.out
Starting secondary namenodes [0.0.0.0]
Step 3 - Verifying Yarn Script
以下命令用于启动 Yarn 脚本。执行此命令将启动您的 Yarn 守护程序。
$ start-yarn.sh
预期输出如下。
starting yarn daemons
starting resourcemanager, logging to /home/hadoop/hadoop-
2.4.1/logs/yarn-hadoop-resourcemanager-localhost.out
localhost: starting nodemanager, logging to /home/hadoop/hadoop-
2.4.1/logs/yarn-hadoop-nodemanager-localhost.out
Installing HBase
我们可以在任何三种模式下安装 HBase:独立模式、伪分布模式和完全分布模式。
Installing HBase in Standalone Mode
使用“wget”命令从 http://www.interior-dsgn.com/apache/hbase/stable/ 下载 HBase 最新稳定版本,然后使用 tar “zxvf”命令将其解压缩。参见以下命令。
$cd usr/local/
$wget http://www.interior-dsgn.com/apache/hbase/stable/hbase-0.98.8-
hadoop2-bin.tar.gz
$tar -zxvf hbase-0.98.8-hadoop2-bin.tar.gz
切换到超级用户模式,并将 HBase 文件夹移动到 /usr/local,如下所示。
$su
$password: enter your password here
mv hbase-0.99.1/* Hbase/
hbase-env.sh
设置 HBase 的 Java 主目录并从 conf 文件夹中打开 hbase-env.sh 文件。编辑 JAVA_HOME 环境变量,并将现有路径更改为当前的 JAVA_HOME 变量,如下所示。
cd /usr/local/Hbase/conf
gedit hbase-env.sh
这将打开 HBase 的 env.sh 文件。现在,用当前值替换现有的 JAVA_HOME 值,如下所示。
export JAVA_HOME=/usr/lib/jvm/java-1.7.0
hbase-site.xml
这是 HBase 的主配置文件。通过在 /usr/local/HBase 中打开 HBase 主文件夹来设置数据目录到合适的位置。在 conf 文件夹中,您将找到几个文件,打开 hbase-site.xml 文件,如下所示。
#cd /usr/local/HBase/
#cd conf
# gedit hbase-site.xml
在 hbase-site.xml 文件中,您将找到 <configuration> 和 </configuration> 标记。在它们内部,在名为“hbase.rootdir”的属性键下设置 HBase 目录,如下所示。
<configuration>
//Here you have to set the path where you want HBase to store its files.
<property>
<name>hbase.rootdir</name>
<value>file:/home/hadoop/HBase/HFiles</value>
</property>
//Here you have to set the path where you want HBase to store its built in zookeeper files.
<property>
<name>hbase.zookeeper.property.dataDir</name>
<value>/home/hadoop/zookeeper</value>
</property>
</configuration>
这样,HBase 安装和配置部分就成功完成了。我们可以使用 HBase bin 文件夹中提供的 start-hbase.sh 脚本启动 HBase。为此,打开 HBase 主文件夹并运行 HBase 开始脚本,如下所示。
$cd /usr/local/HBase/bin
$./start-hbase.sh
如果一切顺利,当您尝试运行 HBase 开始脚本时,它将提示您一条消息,说明 HBase 已经启动。
starting master, logging to /usr/local/HBase/bin/../logs/hbase-tpmaster-localhost.localdomain.out
Installing HBase in Pseudo-Distributed Mode
现在让我们检查在伪分布模式下如何安装 HBase。
在继续 HBase 之前,在本地系统或远程系统上配置 Hadoop 和 HDFS,并确保它们正在运行。如果 HBase 正在运行,请停止它。
hbase-site.xml
编辑 hbase-site.xml 文件以添加以下属性。
<property>
<name>hbase.cluster.distributed</name>
<value>true</value>
</property>
它将提及 HBase 应该在何种模式下运行。在来自本地文件系统的同一文件中,使用 hdfs://// URI 语法更改 hbase.rootdir、您的 HDFS 实例地址。我们正在 localhost 上以 8030 端口运行 HDFS。
<property>
<name>hbase.rootdir</name>
<value>hdfs://localhost:8030/hbase</value>
</property>
Starting HBase
配置完成后,浏览到 HBase 主文件夹并使用以下命令启动 HBase。
$cd /usr/local/HBase
$bin/start-hbase.sh
Note: 在启动 HBase 之前,请确保 Hadoop 正在运行。
Checking the HBase Directory in HDFS
HBase 在 HDFS 中创建其目录。要查看已创建的目录,请浏览到 Hadoop bin 并键入以下命令。
$ ./bin/hadoop fs -ls /hbase
如果一切顺利,它将为您提供以下输出。
Found 7 items
drwxr-xr-x - hbase users 0 2014-06-25 18:58 /hbase/.tmp
drwxr-xr-x - hbase users 0 2014-06-25 21:49 /hbase/WALs
drwxr-xr-x - hbase users 0 2014-06-25 18:48 /hbase/corrupt
drwxr-xr-x - hbase users 0 2014-06-25 18:58 /hbase/data
-rw-r--r-- 3 hbase users 42 2014-06-25 18:41 /hbase/hbase.id
-rw-r--r-- 3 hbase users 7 2014-06-25 18:41 /hbase/hbase.version
drwxr-xr-x - hbase users 0 2014-06-25 21:49 /hbase/oldWALs
Starting and Stopping a Master
使用“local-master-backup.sh”,您可以启动最多 10 个服务器。打开 HBase 主文件夹,主服务器并执行以下命令以启动它。
$ ./bin/local-master-backup.sh 2 4
要终止备份主服务器,您需要它的进程 ID,它将存储在名为 “/tmp/hbase-USER-X-master.pid.” 的文件中,您可以使用以下命令终止备份主服务器。
$ cat /tmp/hbase-user-1-master.pid |xargs kill -9
Starting and Stopping RegionServers
您可以使用以下命令从单个系统运行多个区域服务器。
$ .bin/local-regionservers.sh start 2 3
若要停止区域服务器,请使用以下命令。
$ .bin/local-regionservers.sh stop 3
我无法使用 Gemini 翻译任何内容。
Starting HBaseShell
成功安装 HBase 后,即可启动 HBase Shell。以下为启动 HBase Shell 时需要遵循的步骤序列。打开终端并以超级用户身份登录。
Start Hadoop File System
浏览 Hadoop 主目录 sbin 文件夹并启动 Hadoop 文件系统,如下所示。
$cd $HADOOP_HOME/sbin
$start-all.sh
Start HBase Master Server
这将是同一个目录。按如下所示启动它。
$./bin/local-master-backup.sh start 2 (number signifies specific
server.)
Start HBase Shell
可使用以下命令启动 HBase shell。
$cd bin
$./hbase shell
这会为您提供 HBase Shell 提示,如下所示。
2014-12-09 14:24:27,526 INFO [main] Configuration.deprecation:
hadoop.native.lib is deprecated. Instead, use io.native.lib.available
HBase Shell; enter 'help<RETURN>' for list of supported commands.
Type "exit<RETURN>" to leave the HBase Shell
Version 0.98.8-hadoop2, r6cfc8d064754251365e070a10a82eb169956d5fe, Fri
Nov 14 18:26:29 PST 2014
hbase(main):001:0>
HBase Web Interface
要访问 HBase 的网络界面,在浏览器中键入以下 URL。
http://localhost:60010
此界面列出您当前运行的区域服务器、辅助服务器和 HBase 表。
HBase - Shell
本章解释如何启动 HBase 附带的交互式 shell。
HBase Shell
HBase 包含一个 shell,你可以使用它与 HBase 通信。HBase 使用 Hadoop 文件系统来存储数据。它将拥有一个主服务器和区域服务器。数据存储将以区域(表)的形式进行。这些区域将被拆分为区域服务器中存储。
主服务器管理这些区域服务器并且所有这些任务都在 HDFS 上进行。以下是 HBase Shell 支持的一些命令。
General Commands
-
status - 提供 HBase 的状态,例如服务器数量。
-
version - 提供正在使用的 HBase 版本。
-
table_help - 提供有关引用命令的表帮助。
-
whoami - 提供有关用户的信息。
Data Definition Language
这些是对 HBase 中的表进行操作的命令。
-
create - 创建一个表。
-
list - 列出 HBase 中的所有表。
-
disable - 禁用一个表。
-
is_disabled - 验证一个表是否已禁用。
-
enable - 启用一个表。
-
is_enabled - 验证一个表是否已启用。
-
describe - 提供表的描述信息。
-
alter - 修改一个表。
-
exists - 验证一个表是否存在。
-
drop - 从 HBase 中删除一个表。
-
drop_all - 删除匹配命令中给定的‘正则表达式’的表。
-
Java Admin API - 在上述所有命令之前,Java 提供了一个 Admin API,可以通过编程实现 DDL 功能。在 org.apache.hadoop.hbase.client 包下,HBaseAdmin 和 HTableDescriptor 是该包中提供 DDL 功能的两个重要类。
Data Manipulation Language
-
put - 在特定表的特定行中特定列处放置单元格值。
-
get - 提取行或单元格的内容。
-
delete - 删除表中的单元格值。
-
deleteall - 删除给定行中的所有单元格。
-
scan - 扫描并返回表数据。
-
count - 计算并返回表中的行数。
-
truncate - 禁用、删除和重新创建指定表。
-
Java client API - 在上述所有命令之前,Java 提供了一个客户端 API,可以通过 org.apache.hadoop.hbase.client 包下的编程来实现 DML 功能,即 CRUD (创建检索更新删除)操作等。 HTable Put 和 Get 是该包中的重要类。
Starting HBase Shell
若要访问 HBase shell,您必须导航到 HBase 主文件夹。
cd /usr/localhost/
cd Hbase
您可以使用 “hbase shell” 命令(如下所示)启动 HBase 交互式 shell。
./bin/hbase shell
如果已成功在系统中安装 HBase,那么它会给您 HBase shell 提示(如下所示)。
HBase Shell; enter 'help<RETURN>' for list of supported commands.
Type "exit<RETURN>" to leave the HBase Shell
Version 0.94.23, rf42302b28aceaab773b15f234aa8718fff7eea3c, Wed Aug 27
00:54:09 UTC 2014
hbase(main):001:0>
要随时退出交互式 shell,请键入 exit 或使用 <ctrl+c>。在继续操作前查看 shell 运作情况。为此目的使用 list 命令。 List 是用于获取 HBase 中所有表的列表的命令。首先,使用此命令(如下所示)验证系统中 HBase 的安装和配置。
hbase(main):001:0> list
当您键入此命令时,它会给您以下输出结果。
hbase(main):001:0> list
TABLE
HBase - General Commands
HBase 中的常用命令包括状态、版本、table_help 和 whoami。本章解释了这些命令。
status
该命令返回系统状态,包括在系统上运行的服务器的详细信息。其语法如下:
hbase(main):009:0> status
如果你执行该命令,则会返回以下输出。
hbase(main):009:0> status
3 servers, 0 dead, 1.3333 average load
version
该命令返回你的系统中使用的 HBase 版本。其语法如下:
hbase(main):010:0> version
如果你执行该命令,则会返回以下输出。
hbase(main):009:0> version
0.98.8-hadoop2, r6cfc8d064754251365e070a10a82eb169956d5fe, Fri Nov 14
18:26:29 PST 2014
table_help
该命令指导你如何使用表引用命令以及使用什么表引用命令。以下提供了该命令的语法。
hbase(main):02:0> table_help
当使用该命令时,它会显示与表相关的命令的帮助主题。以下提供了该命令的部分输出。
hbase(main):002:0> table_help
Help for table-reference commands.
You can either create a table via 'create' and then manipulate the table
via commands like 'put', 'get', etc.
See the standard help information for how to use each of these commands.
However, as of 0.96, you can also get a reference to a table, on which
you can invoke commands.
For instance, you can get create a table and keep around a reference to
it via:
hbase> t = create 't', 'cf'…...
HBase - Admin API
HBase 使用 Java 编写,因此提供 Java API 与 HBase 通信。Java API 是与 HBase 通信的最快方式。下面给出了用于管理表的任务的参考 java Admin API。
Class HBaseAdmin
HBaseAdmin 是一个表示 Admin 的类。此类属于 org.apache.hadoop.hbase.client 包。使用此类,可执行管理员任务。可使用 Connection.getAdmin() 方法获取 Admin 实例。
Methods and Description
S.No. |
Methods and Description |
1 |
void createTable(HTableDescriptor desc) 创建新表。 |
2 |
void createTable(HTableDescriptor desc, byte[][] splitKeys) 使用由指定拆分键定义的初始空区域集创建新表。 |
3 |
void deleteColumn(byte[] tableName, String columnName) 从表中删除列。 |
4 |
void deleteColumn(String tableName, String columnName) 从表中删除列。 |
5 |
void deleteTable(String tableName) 删除表。 |
HBase - Create Table
Creating a Table using HBase Shell
您可以使用 create 命令创建一个表,此处您必须指定表名称和列簇名称。在 HBase shell 中创建表的 syntax 如下所示。
create ‘<table name>’,’<column family>’
Creating a Table Using java API
可以使用 HBaseAdmin 类的 createTable() 方法在 HBase 中创建一个表。此类属于 org.apache.hadoop.hbase.client 包。以下是使用 Java API 在 HBase 中创建表的步骤。
Step1: Instantiate HBaseAdmin
此类需要 Configuration 对象作为参数,因此,首先实例化 Configuration 类并将此实例传递给 HBaseAdmin。
Configuration conf = HBaseConfiguration.create();
HBaseAdmin admin = new HBaseAdmin(conf);
Step2: Create TableDescriptor
HTableDescriptor 是属于 org.apache.hadoop.hbase 类的类。此类类似于表名称和列系列的容器。
//creating table descriptor
HTableDescriptor table = new HTableDescriptor(toBytes("Table name"));
//creating column family descriptor
HColumnDescriptor family = new HColumnDescriptor(toBytes("column family"));
//adding coloumn family to HTable
table.addFamily(family);
Step 3: Execute through Admin
使用 HBaseAdmin 类的 createTable() 方法,您可以在 Admin 模式下执行所创建的表。
admin.createTable(table);
以下是通过管理员创建表的完整程序。
import java.io.IOException;
import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.hbase.HColumnDescriptor;
import org.apache.hadoop.hbase.HTableDescriptor;
import org.apache.hadoop.hbase.client.HBaseAdmin;
import org.apache.hadoop.hbase.TableName;
import org.apache.hadoop.conf.Configuration;
public class CreateTable {
public static void main(String[] args) throws IOException {
// Instantiating configuration class
Configuration con = HBaseConfiguration.create();
// Instantiating HbaseAdmin class
HBaseAdmin admin = new HBaseAdmin(con);
// Instantiating table descriptor class
HTableDescriptor tableDescriptor = new
HTableDescriptor(TableName.valueOf("emp"));
// Adding column families to table descriptor
tableDescriptor.addFamily(new HColumnDescriptor("personal"));
tableDescriptor.addFamily(new HColumnDescriptor("professional"));
// Execute the table through admin
admin.createTable(tableDescriptor);
System.out.println(" Table created ");
}
}
编译并执行上述程序,如下所示:
$javac CreateTable.java
$java CreateTable
输出应如下所示:
Table created
HBase - Listing Table
Listing a Table using HBase Shell
list 是用于列出 HBase 中所有表的命令。以下是 list 命令的语法。
hbase(main):001:0 > list
当你键入此命令并在 HBase 提示符中执行它时,它会显示 HBase 中所有表的列表,如下所示。
hbase(main):001:0> list
TABLE
emp
此处你可以看到一个名为 emp 的表。
Listing Tables Using Java API
按照以下步骤使用 java API 从 HBase 获取表格列表。
Step 1
类 HBaseAdmin 中有一个名为 listTables() 的方法,可用于获取 HBase 中所有表的列表。此方法返回 HTableDescriptor 对象的数组。
//creating a configuration object
Configuration conf = HBaseConfiguration.create();
//Creating HBaseAdmin object
HBaseAdmin admin = new HBaseAdmin(conf);
//Getting all the list of tables using HBaseAdmin object
HTableDescriptor[] tableDescriptor = admin.listTables();
Step 2
可以使用 HTableDescriptor 类的 length 变量获取 HTableDescriptor[] 数组的长度。使用 getNameAsString() 方法从该对象获取表的名称。使用这些来运行“for”循环,并获取 HBase 中的表格列表。
下面给出了使用 Java API 列出 HBase 中所有表的程序。
import java.io.IOException;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.hbase.HTableDescriptor;
import org.apache.hadoop.hbase.MasterNotRunningException;
import org.apache.hadoop.hbase.client.HBaseAdmin;
public class ListTables {
public static void main(String args[])throws MasterNotRunningException, IOException{
// Instantiating a configuration class
Configuration conf = HBaseConfiguration.create();
// Instantiating HBaseAdmin class
HBaseAdmin admin = new HBaseAdmin(conf);
// Getting all the list of tables using HBaseAdmin object
HTableDescriptor[] tableDescriptor = admin.listTables();
// printing all the table names.
for (int i=0; i<tableDescriptor.length;i++ ){
System.out.println(tableDescriptor[i].getNameAsString());
}
}
}
编译并执行上述程序,如下所示:
$javac ListTables.java
$java ListTables
输出应如下所示:
User
emp
HBase - Disabling a Table
Disabling a Table using HBase Shell
要删除表或更改其设置,你首先需要使用 disable 命令禁用该表。你可以使用 enable 命令重新启用它。
以下是禁用表语法的说明:
disable ‘emp’
Verification
在禁用表之后,你仍然可以通过 list 与 exists 命令感知它的存在。你无法扫描它。它将给出以下错误。
hbase(main):028:0> scan 'emp'
ROW COLUMN + CELL
ERROR: emp is disabled.
Disable a Table Using Java API
要验证表是否已被禁用,使用 isTableDisabled() 方法,要禁用表,使用 disableTable() 方法。这些方法属于 HBaseAdmin 类。遵循以下步骤来禁用表。
Step 1
按如下所示实例化 HBaseAdmin 类。
// Creating configuration object
Configuration conf = HBaseConfiguration.create();
// Creating HBaseAdmin object
HBaseAdmin admin = new HBaseAdmin(conf);
Step 3
如果该表未禁用,按如下所示禁用它。
if(!b){
admin.disableTable("emp");
System.out.println("Table disabled");
}
以下是用来验证表是否已被禁用的完整程序;如果没有,如何禁用它。
import java.io.IOException;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.hbase.MasterNotRunningException;
import org.apache.hadoop.hbase.client.HBaseAdmin;
public class DisableTable{
public static void main(String args[]) throws MasterNotRunningException, IOException{
// Instantiating configuration class
Configuration conf = HBaseConfiguration.create();
// Instantiating HBaseAdmin class
HBaseAdmin admin = new HBaseAdmin(conf);
// Verifying weather the table is disabled
Boolean bool = admin.isTableDisabled("emp");
System.out.println(bool);
// Disabling the table using HBaseAdmin object
if(!bool){
admin.disableTable("emp");
System.out.println("Table disabled");
}
}
}
编译并执行上述程序,如下所示:
$javac DisableTable.java
$java DsiableTable
输出应如下所示:
false
Table disabled
HBase - Enabling a Table
Enabling a Table using HBase Shell
启用表的语法:
enable ‘emp’
Verification
启用表后,扫描它。如果能看到该架构,则说明表已成功启用。
hbase(main):006:0> scan 'emp'
ROW COLUMN + CELL
1 column = personal data:city, timestamp = 1417516501, value = hyderabad
1 column = personal data:name, timestamp = 1417525058, value = ramu
1 column = professional data:designation, timestamp = 1417532601, value = manager
1 column = professional data:salary, timestamp = 1417524244109, value = 50000
2 column = personal data:city, timestamp = 1417524574905, value = chennai
2 column = personal data:name, timestamp = 1417524556125, value = ravi
2 column = professional data:designation, timestamp = 14175292204, value = sr:engg
2 column = professional data:salary, timestamp = 1417524604221, value = 30000
3 column = personal data:city, timestamp = 1417524681780, value = delhi
3 column = personal data:name, timestamp = 1417524672067, value = rajesh
3 column = professional data:designation, timestamp = 14175246987, value = jr:engg
3 column = professional data:salary, timestamp = 1417524702514, value = 25000
3 row(s) in 0.0400 seconds
is_enabled
此命令用于查找表是否已启用。其语法如下:
hbase> is_enabled 'table name'
以下代码验证名为 emp 的表是否已启用。如果已启用,它将返回 true;如果未启用,它将返回 false。
hbase(main):031:0> is_enabled 'emp'
true
0 row(s) in 0.0440 seconds
Enable a Table Using Java API
要验证表是否已启用,使用 isTableEnabled() 方法;要启用表,使用 enableTable() 方法。这些方法属于 HBaseAdmin 类。按照以下步骤启用表。
Step1
按如下所示实例化 HBaseAdmin 类。
// Creating configuration object
Configuration conf = HBaseConfiguration.create();
// Creating HBaseAdmin object
HBaseAdmin admin = new HBaseAdmin(conf);
Step 3
如果该表未禁用,按如下所示禁用它。
if(!bool){
admin.enableTable("emp");
System.out.println("Table enabled");
}
以下是完整的程序,用于验证表是否已启用,如果未启用,则如何启用它。
import java.io.IOException;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.hbase.MasterNotRunningException;
import org.apache.hadoop.hbase.client.HBaseAdmin;
public class EnableTable{
public static void main(String args[]) throws MasterNotRunningException, IOException{
// Instantiating configuration class
Configuration conf = HBaseConfiguration.create();
// Instantiating HBaseAdmin class
HBaseAdmin admin = new HBaseAdmin(conf);
// Verifying whether the table is disabled
Boolean bool = admin.isTableEnabled("emp");
System.out.println(bool);
// Enabling the table using HBaseAdmin object
if(!bool){
admin.enableTable("emp");
System.out.println("Table Enabled");
}
}
}
编译并执行上述程序,如下所示:
$javac EnableTable.java
$java EnableTable
输出应如下所示:
false
Table Enabled
HBase - Describe & Alter
describe
此命令返回表的描述。其语法如下:
hbase> describe 'table name'
以下是 emp 表上 describe 命令的输出:
hbase(main):006:0> describe 'emp'
DESCRIPTION
ENABLED
'emp', {NAME ⇒ 'READONLY', DATA_BLOCK_ENCODING ⇒ 'NONE', BLOOMFILTER
⇒ 'ROW', REPLICATION_SCOPE ⇒ '0', COMPRESSION ⇒ 'NONE', VERSIONS ⇒
'1', TTL true
⇒ 'FOREVER', MIN_VERSIONS ⇒ '0', KEEP_DELETED_CELLS ⇒ 'false',
BLOCKSIZE ⇒ '65536', IN_MEMORY ⇒ 'false', BLOCKCACHE ⇒ 'true'}, {NAME
⇒ 'personal
data', DATA_BLOCK_ENCODING ⇒ 'NONE', BLOOMFILTER ⇒ 'ROW',
REPLICATION_SCOPE ⇒ '0', VERSIONS ⇒ '5', COMPRESSION ⇒ 'NONE',
MIN_VERSIONS ⇒ '0', TTL
⇒ 'FOREVER', KEEP_DELETED_CELLS ⇒ 'false', BLOCKSIZE ⇒ '65536',
IN_MEMORY ⇒ 'false', BLOCKCACHE ⇒ 'true'}, {NAME ⇒ 'professional
data', DATA_BLO
CK_ENCODING ⇒ 'NONE', BLOOMFILTER ⇒ 'ROW', REPLICATION_SCOPE ⇒ '0',
VERSIONS ⇒ '1', COMPRESSION ⇒ 'NONE', MIN_VERSIONS ⇒ '0', TTL ⇒
'FOREVER', K
EEP_DELETED_CELLS ⇒ 'false', BLOCKSIZE ⇒ '65536', IN_MEMORY ⇒
'false', BLOCKCACHE ⇒ 'true'}, {NAME ⇒ 'table_att_unset',
DATA_BLOCK_ENCODING ⇒ 'NO
NE', BLOOMFILTER ⇒ 'ROW', REPLICATION_SCOPE ⇒ '0', COMPRESSION ⇒
'NONE', VERSIONS ⇒ '1', TTL ⇒ 'FOREVER', MIN_VERSIONS ⇒ '0',
KEEP_DELETED_CELLS
⇒ 'false', BLOCKSIZE ⇒ '6
alter
Alter 是用于对现有表进行更改的命令。使用此命令,您可以更改列系列的最大单元格数,设置和删除表范围运算符,以及从表中删除列系列。
Changing the Maximum Number of Cells of a Column Family
以下是更改列系列的最大单元格数的语法:
hbase> alter 't1', NAME ⇒ 'f1', VERSIONS ⇒ 5
在以下示例中,单元格的最大数目设置为 5。
hbase(main):003:0> alter 'emp', NAME ⇒ 'personal data', VERSIONS ⇒ 5
Updating all regions with the new schema...
0/1 regions updated.
1/1 regions updated.
Done.
0 row(s) in 2.3050 seconds
Table Scope Operators
使用 alter,您可以设置和删除表范围运算符,例如 MAX_FILESIZE、READONLY、MEMSTORE_FLUSHSIZE、DEFERRED_LOG_FLUSH 等。
Setting Read Only
以下是使表变为只读的语法:
hbase>alter 't1', READONLY(option)
在以下示例中,我们使 emp 表变为只读。
hbase(main):006:0> alter 'emp', READONLY
Updating all regions with the new schema...
0/1 regions updated.
1/1 regions updated.
Done.
0 row(s) in 2.2140 seconds
Removing Table Scope Operators
我们还可以移除表作用域运算符。以下是从 emp 表中移除 "MAX_FILESIZE" 的语法:
hbase> alter 't1', METHOD ⇒ 'table_att_unset', NAME ⇒ 'MAX_FILESIZE'
Deleting a Column Family
使用 alter,您还可以删除一个列系列。以下是使用 alter 删除一个列系列的语法:
hbase> alter ‘ table name ’, ‘delete’ ⇒ ‘ column family ’
以下是从 "emp" 表中删除一个列系列的示例:
假设 HBase 中有一个名为 employee 的表。它包含以下数据:
hbase(main):006:0> scan 'employee'
ROW COLUMN+CELL
row1 column = personal:city, timestamp = 1418193767, value = hyderabad
row1 column = personal:name, timestamp = 1418193806767, value = raju
row1 column = professional:designation, timestamp = 1418193767, value = manager
row1 column = professional:salary, timestamp = 1418193806767, value = 50000
1 row(s) in 0.0160 seconds
现在让我们使用 alter 命令删除名为 professional 的列系列。
hbase(main):007:0> alter 'employee','delete'⇒'professional'
Updating all regions with the new schema...
0/1 regions updated.
1/1 regions updated.
Done.
0 row(s) in 2.2380 seconds
现在验证更改后的表中的数据。观察列系列 "professional" 不存在了,因为我们已经将其删除了。
hbase(main):003:0> scan 'employee'
ROW COLUMN + CELL
row1 column = personal:city, timestamp = 14181936767, value = hyderabad
row1 column = personal:name, timestamp = 1418193806767, value = raju
1 row(s) in 0.0830 seconds
Adding a Column Family Using Java API
您可以使用 HBAseAdmin 类的 addColumn() 方法向表中添加一个列系列。按照以下步骤向表中添加一个列系列。
Step 1
实例化 HBaseAdmin 类。
// Instantiating configuration object
Configuration conf = HBaseConfiguration.create();
// Instantiating HBaseAdmin class
HBaseAdmin admin = new HBaseAdmin(conf);
Step 2
addColumn() 方法需要一个表名和一个 HColumnDescriptor 类对象。因此实例化 HColumnDescriptor 类。 HColumnDescriptor 的构造函数又需要一个要添加的列系列名称。这里我们向现有的 "employee" 表中添加一个名为 "contactDetails" 的列系列。
// Instantiating columnDescriptor object
HColumnDescriptor columnDescriptor = new
HColumnDescriptor("contactDetails");
Step 3
使用 addColumn 方法添加列系列。将表名和 HColumnDescriptor 类对象作为参数传递给此方法。
// Adding column family
admin.addColumn("employee", new HColumnDescriptor("columnDescriptor"));
以下是向现有表中添加列系列的完整程序。
import java.io.IOException;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.hbase.HColumnDescriptor;
import org.apache.hadoop.hbase.MasterNotRunningException;
import org.apache.hadoop.hbase.client.HBaseAdmin;
public class AddColoumn{
public static void main(String args[]) throws MasterNotRunningException, IOException{
// Instantiating configuration class.
Configuration conf = HBaseConfiguration.create();
// Instantiating HBaseAdmin class.
HBaseAdmin admin = new HBaseAdmin(conf);
// Instantiating columnDescriptor class
HColumnDescriptor columnDescriptor = new HColumnDescriptor("contactDetails");
// Adding column family
admin.addColumn("employee", columnDescriptor);
System.out.println("coloumn added");
}
}
编译并执行上述程序,如下所示:
$javac AddColumn.java
$java AddColumn
只有在您在 " .bashrc " 中设置了类路径时,上述编译才有效。如果您还没有,请按照以下步骤编译您的 .java 文件。
//if "/home/home/hadoop/hbase " is your Hbase home folder then.
$javac -cp /home/hadoop/hbase/lib/*: Demo.java
如果一切顺利,它将生成以下输出:
column added
Deleting a Column Family Using Java API
您可以使用 HBAseAdmin 类的 deleteColumn() 方法从表中删除一个列系列。按照以下步骤向表中添加一个列系列。
Step1
实例化 HBaseAdmin 类。
// Instantiating configuration object
Configuration conf = HBaseConfiguration.create();
// Instantiating HBaseAdmin class
HBaseAdmin admin = new HBaseAdmin(conf);
Step2
使用 deleteColumn() 方法添加列系列。将表名和列系列名称作为参数传递给此方法。
// Deleting column family
admin.deleteColumn("employee", "contactDetails");
以下是从现有表中删除一个列系列的完整程序。
import java.io.IOException;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.hbase.MasterNotRunningException;
import org.apache.hadoop.hbase.client.HBaseAdmin;
public class DeleteColoumn{
public static void main(String args[]) throws MasterNotRunningException, IOException{
// Instantiating configuration class.
Configuration conf = HBaseConfiguration.create();
// Instantiating HBaseAdmin class.
HBaseAdmin admin = new HBaseAdmin(conf);
// Deleting a column family
admin.deleteColumn("employee","contactDetails");
System.out.println("coloumn deleted");
}
}
编译并执行上述程序,如下所示:
$javac DeleteColumn.java
$java DeleteColumn
输出应如下所示:
column deleted
HBase - Exists
Existence of Table using HBase Shell
使用 exists 命令验证表是否存在。以下示例展示如何使用此命令。
hbase(main):024:0> exists 'emp'
Table emp does exist
0 row(s) in 0.0750 seconds
==================================================================
hbase(main):015:0> exists 'student'
Table student does not exist
0 row(s) in 0.0480 seconds
Verifying the Existence of Table Using Java API
可以使用 HBaseAdmin 类的 tableExists() 方法验证 HBase 中是否存在表。按照以下步骤操作以验证 HBase 中是否存在表。
Step 1
Instantiate the HBaseAdimn class
// Instantiating configuration object
Configuration conf = HBaseConfiguration.create();
// Instantiating HBaseAdmin class
HBaseAdmin admin = new HBaseAdmin(conf);
Step 2
使用 tableExists( ) 方法验证表是否存在。
下面是使用 Java API 测试 HBase 表是否存在的一个 Java 程序。
import java.io.IOException;
import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.client.HBaseAdmin;
public class TableExists{
public static void main(String args[])throws IOException{
// Instantiating configuration class
Configuration conf = HBaseConfiguration.create();
// Instantiating HBaseAdmin class
HBaseAdmin admin = new HBaseAdmin(conf);
// Verifying the existance of the table
boolean bool = admin.tableExists("emp");
System.out.println( bool);
}
}
编译并执行上述程序,如下所示:
$javac TableExists.java
$java TableExists
输出应如下所示:
true
HBase - Drop a Table
Dropping a Table using HBase Shell
您可以使用 drop 命令删除一个表。在删除表之前,您必须禁用它。
hbase(main):018:0> disable 'emp'
0 row(s) in 1.4580 seconds
hbase(main):019:0> drop 'emp'
0 row(s) in 0.3060 seconds
使用 exists 命令验证表是否已删除。
hbase(main):020:07gt; exists 'emp'
Table emp does not exist
0 row(s) in 0.0730 seconds
drop_all
此命令用于删除与该命令中给定的 "regex" 匹配的表。它的语法如下:
hbase> drop_all ‘t.*’
Note: 在删除表格之前,您必须禁用表格。
Example
假设有名称为 raja、rajani、rajendra、rajesh 和 raju 的表格。
hbase(main):017:0> list
TABLE
raja
rajani
rajendra
rajesh
raju
9 row(s) in 0.0270 seconds
所有这些表格均以字母 raj 开头。首先,让我们使用 disable_all 命令禁用所有这些表格,如下所示。
hbase(main):002:0> disable_all 'raj.*'
raja
rajani
rajendra
rajesh
raju
Disable the above 5 tables (y/n)?
y
5 tables successfully disabled
现在您可以使用 drop_all 命令删除它们,如下所示。
hbase(main):018:0> drop_all 'raj.*'
raja
rajani
rajendra
rajesh
raju
Drop the above 5 tables (y/n)?
y
5 tables successfully dropped
Deleting a Table Using Java API
您可以使用 deleteTable() 类中的 HBaseAdmin 方法删除表格。按照以下步骤使用 Java API 删除表格。
Step 1
实例化 HBaseAdmin 类。
// creating a configuration object
Configuration conf = HBaseConfiguration.create();
// Creating HBaseAdmin object
HBaseAdmin admin = new HBaseAdmin(conf);
Step 3
现在使用 HBaseAdmin 类的 deleteTable() 方法删除表格。
admin.deleteTable("emp12");
下面给出了在 HBase 中删除表格的完整 Java 程序。
import java.io.IOException;
import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.client.HBaseAdmin;
public class DeleteTable {
public static void main(String[] args) throws IOException {
// Instantiating configuration class
Configuration conf = HBaseConfiguration.create();
// Instantiating HBaseAdmin class
HBaseAdmin admin = new HBaseAdmin(conf);
// disabling table named emp
admin.disableTable("emp12");
// Deleting emp
admin.deleteTable("emp12");
System.out.println("Table deleted");
}
}
编译并执行上述程序,如下所示:
$javac DeleteTable.java
$java DeleteTable
输出应如下所示:
Table deleted
HBase - Shutting Down
Stopping HBase Using Java API
可以使用 HBaseAdmin 类的 shutdown() 方法关闭 HBase。执行以下步骤以关闭 HBase:
Step 1
实例化 HbaseAdmin 类。
// Instantiating configuration object
Configuration conf = HBaseConfiguration.create();
// Instantiating HBaseAdmin object
HBaseAdmin admin = new HBaseAdmin(conf);
Step 2
使用 HBaseAdmin 类中的 shutdown() 方法关闭 HBase。
admin.shutdown();
以下是用于停止 HBase 的程序。
import java.io.IOException;
import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.client.HBaseAdmin;
public class ShutDownHbase{
public static void main(String args[])throws IOException {
// Instantiating configuration class
Configuration conf = HBaseConfiguration.create();
// Instantiating HBaseAdmin class
HBaseAdmin admin = new HBaseAdmin(conf);
// Shutting down HBase
System.out.println("Shutting down hbase");
admin.shutdown();
}
}
编译并执行上述程序,如下所示:
$javac ShutDownHbase.java
$java ShutDownHbase
输出应如下所示:
Shutting down hbase
HBase - Client API
本章介绍 HBase 的 Java 客户端 API,用于对 HBase 表执行 CRUD 操作。HBase 用 Java 编写,并有一个 Java Native API。因此,它提供了对数据操作语言 (Data Manipulation Language, DML) 的编程访问。
Class HTable
HTable 是 HBase 内部类,表示 HBase 表。它是用于与单个 HBase 表通信的表的实现。此类属于 org.apache.hadoop.hbase.client 类。
Constructors
S.No. |
Constructors and Description |
1 |
HTable() |
2 |
HTable(TableName tableName, ClusterConnection connection, ExecutorService pool) 使用此构造函数,您可以创建对象以访问 HBase 表。 |
Methods and description
S.No. |
Methods and Description |
1 |
void close() 释放 HTable 的所有资源。 |
2 |
void delete(Delete delete) 删除指定的单元格/行。 |
3 |
boolean exists(Get get) 使用此方法,您可以测试 Get 指定的表中是否存在列。 |
4 |
Result get(Get get) 从给定行中检索特定单元格。 |
5 |
org.apache.hadoop.conf.Configuration getConfiguration() 返回此实例使用的 Configuration 对象。 |
6 |
TableName getName() 返回此表的表名实例。 |
7 |
HTableDescriptor getTableDescriptor() 返回此表的表描述符。 |
8 |
byte[] getTableName() 返回此表的名称。 |
9 |
void put(Put put) 使用此方法,您可以向表中插入数据。 |
Class Put
此类用于对单个行执行 Put 操作。它属于 org.apache.hadoop.hbase.client 包。
Constructors
S.No. |
Constructors and Description |
1 |
Put(byte[] row) 使用此构造函数,您可以为指定行创建一个 Put 操作。 |
2 |
Put(byte[] rowArray, int rowOffset, int rowLength) 使用此构造函数,您可以对传入的行键进行复制以供本地保存。 |
3 |
Put(byte[] rowArray, int rowOffset, int rowLength, long ts) 使用此构造函数,您可以对传入行键进行复制以供本地保存。 |
4 |
Put(byte[] row, long ts) 使用此构造函数,我们可以为指定行创建一个 Put 操作,使用指定的时间戳。 |
Methods
S.No. |
Methods and Description |
1 |
Put add(byte[] family, byte[] qualifier, byte[] value) 将指定的列和值添加到此 Put 操作中。 |
2 |
Put add(byte[] family, byte[] qualifier, long ts, byte[] value) 将指定的列和值(指定的时间戳为其版本)添加到此 Put 操作中。 |
3 |
Put add(byte[] family, ByteBuffer qualifier, long ts, ByteBuffer value) 将指定的列和值(指定的时间戳为其版本)添加到此 Put 操作中。 |
4 |
Put add(byte[] family, ByteBuffer qualifier, long ts, ByteBuffer value) 将指定的列和值(指定的时间戳为其版本)添加到此 Put 操作中。 |
Class Get
此类用于对单行执行 Get 操作。此类属于 org.apache.hadoop.hbase.client 包。
Class Delete
此类用于对单行执行 Delete 操作。要删除整行,请实例化一个 Delete 对象,其中包含要删除的行。此类属于 org.apache.hadoop.hbase.client 包。
Constructor
S.No. |
Constructor and Description |
1 |
Delete(byte[] row) 为指定行创建 Delete 操作。 |
2 |
Delete(byte[] rowArray, int rowOffset, int rowLength) 为指定行和时间戳创建 Delete 操作。 |
3 |
Delete(byte[] rowArray, int rowOffset, int rowLength, long ts) 为指定行和时间戳创建 Delete 操作。 |
4 |
Delete(byte[] row, long timestamp) 为指定行和时间戳创建 Delete 操作。 |
Methods
S.No. |
Methods and Description |
1 |
Delete addColumn(byte[] family, byte[] qualifier) 删除指定列的最新版本。 |
2 |
Delete addColumns(byte[] family, byte[] qualifier, long timestamp) 删除所有版本的时间戳小于或等于指定时间戳的指定列。 |
3 |
Delete addFamily(byte[] family) 删除指定族的所有列的所有版本。 |
4 |
Delete addFamily(byte[] family, long timestamp) 删除时间戳小于或等于指定时间戳的指定族的所有列。 |
HBase - Create Data
Inserting Data using HBase Shell
本章演示如何在 HBase 表中创建数据。要创建 HBase 表中的数据,请使用以下命令和方法:
-
put command,
-
Put 类的 add() 方法;和
-
HTable 类的 put() 方法。
例如,我们要在 HBase 中创建以下表。
使用 put 命令,你可以向表中插入行。其语法如下:
put ’<table name>’,’row1’,’<colfamily:colname>’,’<value>’
Inserting the First Row
让我们按如下所示向 emp 表中插入第一行值。
hbase(main):005:0> put 'emp','1','personal data:name','raju'
0 row(s) in 0.6600 seconds
hbase(main):006:0> put 'emp','1','personal data:city','hyderabad'
0 row(s) in 0.0410 seconds
hbase(main):007:0> put 'emp','1','professional
data:designation','manager'
0 row(s) in 0.0240 seconds
hbase(main):007:0> put 'emp','1','professional data:salary','50000'
0 row(s) in 0.0240 seconds
以相同的方式使用 put 命令插入其余行。如果你插入整个表,你将获得以下输出。
hbase(main):022:0> scan 'emp'
ROW COLUMN+CELL
1 column=personal data:city, timestamp=1417524216501, value=hyderabad
1 column=personal data:name, timestamp=1417524185058, value=ramu
1 column=professional data:designation, timestamp=1417524232601,
value=manager
1 column=professional data:salary, timestamp=1417524244109, value=50000
2 column=personal data:city, timestamp=1417524574905, value=chennai
2 column=personal data:name, timestamp=1417524556125, value=ravi
2 column=professional data:designation, timestamp=1417524592204,
value=sr:engg
2 column=professional data:salary, timestamp=1417524604221, value=30000
3 column=personal data:city, timestamp=1417524681780, value=delhi
3 column=personal data:name, timestamp=1417524672067, value=rajesh
3 column=professional data:designation, timestamp=1417524693187,
value=jr:engg
3 column=professional data:salary, timestamp=1417524702514,
value=25000
Inserting Data Using Java API
您可以使用 Put 类的 add() 方法向 HBase 插入数据。您可以使用 HTable 类的 put() 方法进行保存。这些类属于 org.apache.hadoop.hbase.client 包。以下是创建 HBase 表中的数据的步骤
Step 1:Instantiate the Configuration Class
Configuration 类将 HBase 配置文件添加到其对象中。您可以使用 HbaseConfiguration 类的 create() 方法创建一个配置对象,如下所示。
Configuration conf = HbaseConfiguration.create();
Step 2:Instantiate the HTable Class
您有一个名为 HTable 的类,它是 HBase 中 Table 的实现。该类用于与单个 HBase 表进行通信。在实例化该类时,它接受配置对象和表名作为参数。您可以如下所示实例化 HTable 类。
HTable hTable = new HTable(conf, tableName);
Step 3: Instantiate the PutClass
若要将数据插入 HBase 表,请使用 add() 方法及其变体。该方法属于 Put ,因此实例化 put 类。该类需要以字符串格式的你要向其插入数据的行名称。您可以如下所示实例化 Put 类。
Put p = new Put(Bytes.toBytes("row1"));
Step 4: InsertData
使用 Put 类的 add() 方法插入数据。它需要分别表示列族、列限定符(列名)和要插入的值的 3 个字节数组。使用 add() 方法将数据插入 HBase 表,如下所示。
p.add(Bytes.toBytes("coloumn family "), Bytes.toBytes("column
name"),Bytes.toBytes("value"));
Step 6: Close the HTable Instance
在 HBase 表中创建数据后,使用 close() 方法关闭 HTable 实例,如下所示。
hTable.close();
以下是创建 HBase 表中数据的完整程序。
import java.io.IOException;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.hbase.client.HTable;
import org.apache.hadoop.hbase.client.Put;
import org.apache.hadoop.hbase.util.Bytes;
public class InsertData{
public static void main(String[] args) throws IOException {
// Instantiating Configuration class
Configuration config = HBaseConfiguration.create();
// Instantiating HTable class
HTable hTable = new HTable(config, "emp");
// Instantiating Put class
// accepts a row name.
Put p = new Put(Bytes.toBytes("row1"));
// adding values using add() method
// accepts column family name, qualifier/row name ,value
p.add(Bytes.toBytes("personal"),
Bytes.toBytes("name"),Bytes.toBytes("raju"));
p.add(Bytes.toBytes("personal"),
Bytes.toBytes("city"),Bytes.toBytes("hyderabad"));
p.add(Bytes.toBytes("professional"),Bytes.toBytes("designation"),
Bytes.toBytes("manager"));
p.add(Bytes.toBytes("professional"),Bytes.toBytes("salary"),
Bytes.toBytes("50000"));
// Saving the put Instance to the HTable.
hTable.put(p);
System.out.println("data inserted");
// closing HTable
hTable.close();
}
}
编译并执行上述程序,如下所示:
$javac InsertData.java
$java InsertData
输出应如下所示:
data inserted
HBase - Update Data
Updating Data using HBase Shell
你可以使用 put 命令更新现有单元格值。为此,只需遵循相同的语法,然后提及你的新值,如下所示。
put ‘table name’,’row ’,'Column family:column name',’new value’
新给定的值将替换现有值,从而更新该行。
Example
假设 HBase 中有一个名为 emp 的表,其中包含如下数据。
hbase(main):003:0> scan 'emp'
ROW COLUMN + CELL
row1 column = personal:name, timestamp = 1418051555, value = raju
row1 column = personal:city, timestamp = 1418275907, value = Hyderabad
row1 column = professional:designation, timestamp = 14180555,value = manager
row1 column = professional:salary, timestamp = 1418035791555,value = 50000
1 row(s) in 0.0100 seconds
以下命令会将名为“Raju”的员工的所在地更新为德里。
hbase(main):002:0> put 'emp','row1','personal:city','Delhi'
0 row(s) in 0.0400 seconds
更新后的表格如下所示,你可以看到 Raju 所在城市已变更为“德里”。
hbase(main):003:0> scan 'emp'
ROW COLUMN + CELL
row1 column = personal:name, timestamp = 1418035791555, value = raju
row1 column = personal:city, timestamp = 1418274645907, value = Delhi
row1 column = professional:designation, timestamp = 141857555,value = manager
row1 column = professional:salary, timestamp = 1418039555, value = 50000
1 row(s) in 0.0100 seconds
Updating Data Using Java API
你可以使用 put() 方法更新特定单元格中的数据。按照以下给定的步骤更新表的现有单元格值。
Step 1: Instantiate the Configuration Class
Configuration 类将其 HBase 配置文件添加到其对象中。你可以使用 HbaseConfiguration 类的 create() 方法创建一个配置对象,如下所示。
Configuration conf = HbaseConfiguration.create();
Step 2: Instantiate the HTable Class
你有一个名为 HTable 的类,是 Table 在 HBase 中的一个实现。该类用于与单个 HBase 表通信。在实例化该类时,它将接受配置对象和表名作为参数。你可以如下所示实例化 HTable 类。
HTable hTable = new HTable(conf, tableName);
Step 3: Instantiate the Put Class
要将数据插入到 HBase 表中,可以使用 add() 方法及其变体。该方法属于 Put ,因此实例化 put 类。此类需要你想要在其中插入数据的行名(字符串格式)。你可以如下所示实例化 Put 类。
Put p = new Put(Bytes.toBytes("row1"));
Step 4: Update an Existing Cell
Put 类的 add() 方法用于插入数据。它需要 3 个字节数组,分别表示列族、列限定符(列名)和要插入的值。如下所示使用 add() 方法将数据插入到 HBase 表中。
p.add(Bytes.toBytes("coloumn family "), Bytes.toBytes("column
name"),Bytes.toBytes("value"));
p.add(Bytes.toBytes("personal"),
Bytes.toBytes("city"),Bytes.toBytes("Delih"));
Step 6: Close HTable Instance
在 HBase 表中创建数据后,使用 close() 方法关闭 HTable 实例,如下所示。
hTable.close();
下面给出了用于更新特定表中数据的完整程序。
import java.io.IOException;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.hbase.client.HTable;
import org.apache.hadoop.hbase.client.Put;
import org.apache.hadoop.hbase.util.Bytes;
public class UpdateData{
public static void main(String[] args) throws IOException {
// Instantiating Configuration class
Configuration config = HBaseConfiguration.create();
// Instantiating HTable class
HTable hTable = new HTable(config, "emp");
// Instantiating Put class
//accepts a row name
Put p = new Put(Bytes.toBytes("row1"));
// Updating a cell value
p.add(Bytes.toBytes("personal"),
Bytes.toBytes("city"),Bytes.toBytes("Delih"));
// Saving the put Instance to the HTable.
hTable.put(p);
System.out.println("data Updated");
// closing HTable
hTable.close();
}
}
编译并执行上述程序,如下所示:
$javac UpdateData.java
$java UpdateData
输出应如下所示:
data Updated
HBase - Read Data
Reading Data using HBase Shell
get 命令和 get() 方法的 HTable 类用于从 HBase 中某张表读取数据。使用 get 命令,您一次只能获取一行数据。它的语法如下所示:
get ’<table name>’,’row1’
Example
以下示例显示如何使用 get 命令。让我们扫描 emp 表的第一行。
hbase(main):012:0> get 'emp', '1'
COLUMN CELL
personal : city timestamp = 1417521848375, value = hyderabad
personal : name timestamp = 1417521785385, value = ramu
professional: designation timestamp = 1417521885277, value = manager
professional: salary timestamp = 1417521903862, value = 50000
4 row(s) in 0.0270 seconds
Reading a Specific Column
下面给出使用 get 方法读取特定列的语法。
hbase> get 'table name', ‘rowid’, {COLUMN ⇒ ‘column family:column name ’}
Reading Data Using Java API
要从 HBase 表中读取数据,请使用 HTable 类的 get() 方法。此方法需要 Get 类的实例。按照以下步骤从 HBase 表中检索数据。
Step 1: Instantiate the Configuration Class
Configuration 类将其 HBase 配置文件添加到其对象中。你可以使用 HbaseConfiguration 类的 create() 方法创建一个配置对象,如下所示。
Configuration conf = HbaseConfiguration.create();
Step 2: Instantiate the HTable Class
你有一个名为 HTable 的类,是 Table 在 HBase 中的一个实现。该类用于与单个 HBase 表通信。在实例化该类时,它将接受配置对象和表名作为参数。你可以如下所示实例化 HTable 类。
HTable hTable = new HTable(conf, tableName);
Step 3: Instantiate the Get Class
您可以使用 HTable 类的 get() 方法从 HBase 表中检索数据。此方法从给定行中提取一个单元格。它需要一个 Get 类对象作为参数。如下所示创建它。
Get get = new Get(toBytes("row1"));
Step 4: Read the Data
在检索数据时,您可以按 ID 获取单行,或按一组行 ID 获取一组行,或扫描整个表或一组行。
可以使用 Get 类中的 add 方法变量来检索 HBase 表数据。
要从特定列族获取特定列,请使用以下方法。
get.addFamily(personal)
要从特定列族获取所有列,请使用以下方法。
get.addColumn(personal, name)
Step 5: Get the Result
通过将 Get 类实例传递给 HTable 类的 get 方法来获取结果。此方法返回 Result 类对象,该对象保存所请求的结果。下面是 get() 方法的用法。
Result result = table.get(g);
Step 6: Reading Values from the Result Instance
Result 类提供了 getValue() 方法来读取其实例中的值。如下所示使用它从 Result 实例中读取值。
byte [] value = result.getValue(Bytes.toBytes("personal"),Bytes.toBytes("name"));
byte [] value1 = result.getValue(Bytes.toBytes("personal"),Bytes.toBytes("city"));
下面给出从 HBase 表中读取值的完整程序。
import java.io.IOException;
import org.apache.hadoop.conf.Configuration;
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.Result;
import org.apache.hadoop.hbase.util.Bytes;
public class RetriveData{
public static void main(String[] args) throws IOException, Exception{
// Instantiating Configuration class
Configuration config = HBaseConfiguration.create();
// Instantiating HTable class
HTable table = new HTable(config, "emp");
// Instantiating Get class
Get g = new Get(Bytes.toBytes("row1"));
// Reading the data
Result result = table.get(g);
// Reading values from Result class object
byte [] value = result.getValue(Bytes.toBytes("personal"),Bytes.toBytes("name"));
byte [] value1 = result.getValue(Bytes.toBytes("personal"),Bytes.toBytes("city"));
// Printing the values
String name = Bytes.toString(value);
String city = Bytes.toString(value1);
System.out.println("name: " + name + " city: " + city);
}
}
编译并执行上述程序,如下所示:
$javac RetriveData.java
$java RetriveData
输出应如下所示:
name: Raju city: Delhi
HBase - Delete Data
Deleting a Specific Cell in a Table
使用 delete 命令,您可以在表中删除特定单元格。 delete 命令的语法如下所示:
delete ‘<table name>’, ‘<row>’, ‘<column name >’, ‘<time stamp>’
Deleting All Cells in a Table
使用 “deleteall” 命令,您可以删除一行中的所有 cell。下面给出了 deleteall 命令的语法。
deleteall ‘<table name>’, ‘<row>’,
Example
这是一个“deleteall”命令的示例,在这里我们正在删除 emp 表的第一行所有 cell。
hbase(main):007:0> deleteall 'emp','1'
0 row(s) in 0.0240 seconds
使用 scan 命令验证表。下面给出了删除表后的表快照。
hbase(main):022:0> scan 'emp'
ROW COLUMN + CELL
2 column = personal data:city, timestamp = 1417524574905, value = chennai
2 column = personal data:name, timestamp = 1417524556125, value = ravi
2 column = professional data:designation, timestamp = 1417524204, value = sr:engg
2 column = professional data:salary, timestamp = 1417524604221, value = 30000
3 column = personal data:city, timestamp = 1417524681780, value = delhi
3 column = personal data:name, timestamp = 1417524672067, value = rajesh
3 column = professional data:designation, timestamp = 1417523187, value = jr:engg
3 column = professional data:salary, timestamp = 1417524702514, value = 25000
Deleting Data Using Java API
您可以使用 HTable 类的 delete() 方法从 HBase 表中删除数据。按照以下步骤从表中删除数据。
Step 1: Instantiate the Configuration Class
Configuration 类将 HBase 配置文件添加到其对象中。您可以使用 HbaseConfiguration 类的 create() 方法创建配置对象,如下所示。
Configuration conf = HbaseConfiguration.create();
Step 2: Instantiate the HTable Class
你有一个名为 HTable 的类,是 Table 在 HBase 中的一个实现。该类用于与单个 HBase 表通信。在实例化该类时,它将接受配置对象和表名作为参数。你可以如下所示实例化 HTable 类。
HTable hTable = new HTable(conf, tableName);
Step 3: Instantiate the Delete Class
通过传递要删除的行 rowid(以字节数组格式)来实例化 Delete 类。您还可以将时间戳和 Rowlock 传递到此构造函数。
Delete delete = new Delete(toBytes("row1"));
Step 4: Select the Data to be Deleted
您可以使用 Delete 类的 delete 方法删除数据。这个类有各种删除方法。使用这些方法选择要删除的列或列系列。查看显示 Delete 类方法用法以下示例。
delete.deleteColumn(Bytes.toBytes("personal"), Bytes.toBytes("name"));
delete.deleteFamily(Bytes.toBytes("professional"));
Step 6: Close the HTableInstance
删除数据后,关闭 HTable 实例。
table.close();
下面给出从 HBase 表中删除数据的完整程序。
import java.io.IOException;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.hbase.client.Delete;
import org.apache.hadoop.hbase.client.HTable;
import org.apache.hadoop.hbase.util.Bytes;
public class DeleteData {
public static void main(String[] args) throws IOException {
// Instantiating Configuration class
Configuration conf = HBaseConfiguration.create();
// Instantiating HTable class
HTable table = new HTable(conf, "employee");
// Instantiating Delete class
Delete delete = new Delete(Bytes.toBytes("row1"));
delete.deleteColumn(Bytes.toBytes("personal"), Bytes.toBytes("name"));
delete.deleteFamily(Bytes.toBytes("professional"));
// deleting the data
table.delete(delete);
// closing the HTable object
table.close();
System.out.println("data deleted.....");
}
}
编译并执行上述程序,如下所示:
$javac Deletedata.java
$java DeleteData
输出应如下所示:
data deleted
HBase - Scan
Scaning using HBase Shell
scan 命令用于查看 HTable 中的数据。使用 scan 命令,您可以获取表数据。它的语法如下:
scan ‘<table name>’
Example
以下示例演示如何使用 scan 命令从表中读取数据。这里我们正在读取 emp 表。
hbase(main):010:0> scan 'emp'
ROW COLUMN + CELL
1 column = personal data:city, timestamp = 1417521848375, value = hyderabad
1 column = personal data:name, timestamp = 1417521785385, value = ramu
1 column = professional data:designation, timestamp = 1417585277,value = manager
1 column = professional data:salary, timestamp = 1417521903862, value = 50000
1 row(s) in 0.0370 seconds
Scanning Using Java API
使用 java API 扫描整个表数据的完整程序如下。
import java.io.IOException;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.hbase.util.Bytes;
import org.apache.hadoop.hbase.client.HTable;
import org.apache.hadoop.hbase.client.Result;
import org.apache.hadoop.hbase.client.ResultScanner;
import org.apache.hadoop.hbase.client.Scan;
public class ScanTable{
public static void main(String args[]) throws IOException{
// Instantiating Configuration class
Configuration config = HBaseConfiguration.create();
// Instantiating HTable class
HTable table = new HTable(config, "emp");
// Instantiating the Scan class
Scan scan = new Scan();
// Scanning the required columns
scan.addColumn(Bytes.toBytes("personal"), Bytes.toBytes("name"));
scan.addColumn(Bytes.toBytes("personal"), Bytes.toBytes("city"));
// Getting the scan result
ResultScanner scanner = table.getScanner(scan);
// Reading values from scan result
for (Result result = scanner.next(); result != null; result = Scanner.next())
System.out.println("Found row : " + result);
//closing the scanner
scanner.close();
}
}
编译并执行上述程序,如下所示:
$javac ScanTable.java
$java ScanTable
输出应如下所示:
Found row :
keyvalues={row1/personal:city/1418275612888/Put/vlen=5/mvcc=0,
row1/personal:name/1418035791555/Put/vlen=4/mvcc=0}
HBase - Count & Truncate
count
您可以使用 count 命令计算表的行数。它的语法如下:
count ‘<table name>’
删除第一行后,emp 表将有两行。如下所示进行验证。
hbase(main):023:0> count 'emp'
2 row(s) in 0.090 seconds
⇒ 2
truncate
此命令禁用删除并重新创建表。 truncate 的语法如下:
hbase> truncate 'table name'
Example
下面给出了 truncate 命令的示例。在这里我们截断了 emp 表。
hbase(main):011:0> truncate 'emp'
Truncating 'one' table (it may take a while):
- Disabling table...
- Truncating table...
0 row(s) in 1.5950 seconds
截断表后,使用 scan 命令进行验证。您将得到一个零行的表。
hbase(main):017:0> scan ‘emp’
ROW COLUMN + CELL
0 row(s) in 0.3110 seconds
HBase - Security
我们可以在 HBase 中向用户授予和撤销权限。出于安全目的,有三个命令:授予、撤销和用户权限。
grant
grant 命令授予特定权限,例如对某个表的读、写、执行和管理权限。grant 命令的语法如下:
hbase> grant <user> <permissions> [<table> [<column family> [<column; qualifier>]]
我们可以从 RWXCA 集合中向用户授予零个或更多权限,其中
-
R - 表示读取权限。
-
W - 表示写入权限。
-
X - 表示执行权限。
-
C - 表示创建权限。
-
A - 表示管理权限。
下面给出的示例授予名为“Tutorialspoint”的用户所有权限。
hbase(main):018:0> grant 'Tutorialspoint', 'RWXCA'