1.Hive
官方网址：http://hive.apache.org/
? 什么是Hive？（***了解***）
l Hive 是建立在 Hadoop上的数据仓库基础构架。它提供了一系列的工具，可以用来进行数据提取转化加载（ETL ），这是一种可以存储、查询和分析存储在 Hadoop 中的大规模数据的机制。Hive 定义了简单的类 SQL 查询语言，称为 HiveQL ，它允许熟悉 SQL 的用户查询数据。同时，这个语言也允许熟悉 MapReduce 开发者的开发自定义的 mapper 和 reducer 来处理内建的 mapper 和 reducer 无法完成的复杂的分析工作。
l Hive是SQL解析引擎，它将SQL语句转译成M/R Job然后在Hadoop执行。
l Hive的表其实就是HDFS的目录/文件，按表名把文件夹分开。如果是分区表，则分区值是子文件夹，可以直接在M/R Job里使用这些数据。
? Hive的系统架构？（***掌握***）
l 用户接口，包括 CLI，JDBC/ODBC，WebUI
l 元数据存储，通常是存储在关系数据库如 mysql, derby 中
l 解释器、编译器、优化器、执行器
l Hadoop：用 HDFS 进行存储，利用 MapReduce 进行计算
1．用户接口主要有三个：CLI，JDBC/ODBC和 WebUI
1) CLI，即Shell命令行
2) JDBC/ODBC 是 Hive 的Java，与使用传统数据库JDBC的方式类似
3) WebGUI是通过浏览器访问 Hive
hive web界面的 (端口号9999) 启动方式
#hive --service hwi&
用于通过浏览器来访问hive
http://nameNode1:9999/hwi/
注意要下载hive-hwi-0.12.0.war放到lib的目录下。
l Hive 将元数据存储在数据库中(metastore)，目前只支持 mysql、derby。Hive 中的元数据包括表的名字，表的列和分区及其属性，表的属性（是否为外部表等），表的数据所在目录等
l 解释器、编译器、优化器完成 HQL 查询语句从词法分析、语法分析、编译、优化以及查询计划（plan）的生成。生成的查询计划存储在 HDFS 中，并在随后有 MapReduce 调用执行。
l Hive 的数据存储在 HDFS 中，大部分的查询由 MapReduce 完成（包含 * 的查询，比如 select * from table 不会生成 MapRedcue 任务）
? Hive的metastore（***知道***）
l metastore是hive元数据的集中存放地。
l metastore默认使用内嵌的derby数据库作为存储引擎
l Derby引擎的缺点：一次只能打开一个会话
l 使用Mysql作为外置存储引擎，多用户同时访问
例子：
把hive-0.12.0.tar.gz解压到/itcast/
# tar -zxvf hive-0.12.0.tar.gz -C /itcast
# cd /itcast/hive-0.12.0/bin
# ./hive
hive> create database test_db;
hive>show databases;
发现存在test_db;
我们cd到hive目录下，发现test_db的默认derby数据库存储引擎。
而我们cd /itcast/hive-0.12.0下执行
#./bin/hive
hive>show databases;
发现没有找到test_db数据库。
说明：derby数据库默认创建在当前目录下。
? Hive mysql的metastore安装准备（***掌握***）
在nameNode1机子上实践：
把hive-0.12.0.tar.gz解压到/itcast/
# tar -zxvf hive-0.12.0.tar.gz -C /itcast
修改/etc/profile文件，将hive加入环境变量
# vim /etc/profile
export JAVA_HOME=/usr/java/jdk1.7.0_79
export HADOOP_HOME=/itcast/hadoop-2.4.1
export HIVE_HOME=/itcast/hive-0.12.0
export PATH=$PATH:$JAVA_HOME/bin:$HADOOP_HOME/bin:$HADOOP_HOME/sbin:$HIVE_HOME/bin
Source 一下，让配置生效
# source /etc/profile
安装完毕！
提示：metastore是hive元数据的集中存放地。metastore默认使用内嵌的derby数据库作为存储引擎。Derby引擎的缺点：一次只能打开一个会话，使用Mysql作为外置存储引擎，多用户同时访问。
? 安装mysql数据库（***掌握****）
（注意：没网络，可以配置好本地yum源）
# yum -y install mysql-server
启动mysql数据库
# service mysqld start
初始化mysql数据库（默认root的密码为空，按提示一步步完成）
# /usr/bin/mysql_secure_installation
将mysql加入开机启动
# chkconfig mysqld on
允许远程登录mysql
首先登录mysql数据，然后执行下面两行语句：
GRANT ALL PRIVILEGES ON *.* TO ‘root‘@‘%‘ IDENTIFIED BY ‘itcast‘ WITH GRANT OPTION;
flush privileges;
修改$HIVE_HOME/bin的hive-config.sh，增加以下三行
export JAVA_HOME=/usr/java/jdk1.7.0_79
export HIVE_HOME=/itcast/hive-0.12.0
export HADOOP_HOME=/itcast/hadoop-2.4.1
? 配置MySQL的metastore（***掌握***）
上传数据库驱动mysql-connector-java-5.1.28.jar到/itcast/hive-0.12.0/lib
修改$HIVE_HOME/conf/hive-site.xml
# vim /itcast/hive-0.12.0/conf/hive-site.xml
<configuration>
<property>
<name>javax.jdo.option.ConnectionURL</name>
<value>jdbc:mysql://localhost:3306/hive?createDatabaseIfNotExist=true</value>
</property>
<property>
<name>javax.jdo.option.ConnectionDriverName</name>
<value>com.mysql.jdbc.Driver</value>
</property>
<property>
<name>javax.jdo.option.ConnectionUserName</name>
<value>root</value>
</property>
<property>
<name>javax.jdo.option.ConnectionPassword</name>
<value>itcast</value>
</property>
</configuration>
配置完毕！
? 测试配置是否正确（***掌握***）
启动hive
# hive
创建数据库
hive> create database test_db;
显示所有数据库
show databases;
使用数据库test_db
hive> use test_db;
创建学生表
hive> create table student(id int,name string);
查看是否在HDFS中存有下面文件夹
http://namenode1:50070/explorer.html#/user/hive/warehouse/test_db.db/student
? Hive与传统数据库区别（***了解***）
? Hive的数据类型（***掌握***）
l 基本数据类型
tinyint/smallint/int/bigint
float/double
boolean
string
l 复杂数据类型
Array/Map/Struct
注意：没有date/datetime类型
? Hive的数据存储（***知道***）
1．Hive的数据存储基于Hadoop HDFS
2．Hive没有专门的数据存储格式
3．存储结构主要包括：数据库、文件、表、视图
4．Hive默认可以直接加载文本文件（TextFile），还支持sequence file 、RC file
5．创建表时，指定Hive数据的列分隔符与行分隔符，Hive即可解析数据
? Hive的数据模型-数据库
l 类似传统数据库的DataBase
l 默认数据库"default"
l 使用#hive命令后，不使用hive>use <数据库名>，系统默认的数据库。可以显式使用hive> use default;
? Hive的数据模型-表（***掌握***）
l Table 内部表
l Partition 分区表
l External Table 外部表
l Bucket Table 桶表
? Hive的数据模型-内部表（***实践***）
l 与数据库中的 Table 在概念上是类似
l 每一个 Table 在 Hive 中都有一个相应的目录存储数据。例如，一个表 test，它在 HDFS 中的路径为：/ warehouse/test。 warehouse是在 hive-site.xml 中由 ${hive.metastore.warehouse.dir} 指定的数据仓库的目录
l 所有的 Table 数据（不包括 External Table）都保存在这个目录中。
l 删除表时，元数据与数据都会被删除
例子：
创建数据文件inner_table.dat
创建表
hive>create table inner_table (key string);
加载数据
hive>load data local inpath ‘/root/inner_table.dat‘ into table inner_table;
查看数据
select * from inner_table;
select count(*) from inner_table;
删除表 drop table inner_table;
? Hive的数据模型-分区表（***实践***）
l Partition 对应于数据库的 Partition 列的密集索引
l 在 Hive 中，表中的一个 Partition 对应于表下的一个目录，所有的 Partition 的数据都存储在对应的目录中
例如：
test表中包含 date 和 city 两个 Partition，
则对应于date=20130201, city = bj 的 HDFS 子目录为：
/warehouse/test/date=20130201/city=bj
对应于date=20130202, city=sh 的HDFS 子目录为；
/warehouse/test/date=20130202/city=sh
语法：
CREATE TABLE tmp_table #表名
(
title string, # 字段名称 字段类型
minimum_bid double,
quantity bigint,
have_invoice bigint
)COMMENT ‘注释：XXX‘ #表注释
PARTITIONED BY(pt STRING) #分区表字段（如果你文件非常之大的话，采用分区表可以快过滤出按分区字段划分的数据）
ROW FORMAT DELIMITED
FIELDS TERMINATED BY ‘\001‘ # 字段是用什么分割开的
STORED AS SEQUENCEFILE; #用哪种方式存储数据，SEQUENCEFILE是hadoop自带的文件压缩格式
一些相关命令：
SHOW TABLES; # 查看所有的表
SHOW TABLES ‘*TMP*‘; #支持模糊查询
SHOW PARTITIONS TMP_TABLE; #查看表有哪些分区
DESCRIBE TMP_TABLE; #查看表结构
实例：
创建数据文件partition_table.dat
创建表
create table partition_table(rectime string,msisdn string)COMMENT ‘’ partitioned by(daytime string,city string) row format delimited fields terminated by ‘\t‘ stored as TEXTFILE;
加载数据到分区
load data local inpath ‘/root/partition_table.dat‘ into table partition_table partition (daytime=‘2015-07-16‘,city=‘bj‘);
查看数据
select * from partition_table;
select count(*) from partition_table;
往partition添加一个分区
alter table partition_table add partition (daytime=‘2015-07-07‘,city=‘bj‘);
先导入
load data local inpath ‘/root/partition_table.dat‘ into table partition_table partition (daytime=‘2015-07-07‘,city=‘bj‘);
元数据，数据文件删除，但目录daytime=2015-07-07还在
alter table partition_table drop partition (daytime=‘2015-07-07‘,city=‘bj‘);
删除表 drop table partition_table;
? Hive的数据模型—桶表(***掌握***）
l 桶表是对数据进行哈希取值，然后放到不同文件中存储。
创建表
create table bucket_table(id string) clustered by(id) into 4 buckets;
l 加载数据
set hive.enforce.bucketing = true;
insert into table bucket_table select name from stu;
insert overwrite table bucket_table select name from stu;
l 数据加载到桶表时，会对字段取hash值，然后与桶的数量取模。把数据放到对应的文件中。
l 抽样查询
select * from bucket_table tablesample(bucket 1 out of 4 on id);
? Hive的数据模型-外部表（***掌握***）
l 指向已经在 HDFS 中存在的数据，可以创建 Partition
l 它和内部表 在元数据的组织上是相同的，而实际数据的存储则有较大的差异
l 内部表的创建过程和数据加载过程（这两个过程可以在同一个语句中完成），在加载数据的过程中，实际数据会被移动到数据仓库目录中；之后对数据对访问将会直接在数据仓库目录中完成。删除表时，表中的数据和元数据将会被同时删除
l 外部表 只有一个过程，加载数据和创建表同时完成，并不会移动到数据仓库目录中，只是与外部数据建立一个链接。当删除一个 外部表 时，仅删除该链接
语法：
CREATE EXTERNAL TABLE page_view
( viewTime INT,
userid BIGINT,
page_url STRING,
referrer_url STRING,
ip STRING COMMENT ‘IP Address of the User‘,
country STRING COMMENT ‘country of origination‘
)
COMMENT ‘This is the staging page view table‘
ROW FORMAT DELIMITED FIELDS TERMINATED BY ‘44‘ LINES TERMINATED BY ‘12‘
STORED AS TEXTFILE
LOCATION ‘hdfs://centos:9000/user/data/staging/page_view‘;
例子：
创建数据文件external_table.dat
创建表
hive>create external table external_table1 (key string) ROW FORMAT DELIMITED FIELDS TERMINATED BY ‘\t‘ location ‘/home/external‘;
在HDFS创建目录/home/external
#hadoop fs -put /home/external_table.dat /home/external
加载数据
LOAD DATA INPATH ‘/home/external_table1.dat‘ INTO TABLE external_table1;
查看数据
select * from external_table
select count(*) from external_table
删除表
drop table external_table
? 视图操作（***了解***）
视图的创建
CREATE VIEW v1 AS select * from t1;
? 表的操作（***掌握***）
表的修改
alter table target_tab add columns (cols,string)
表的删除
drop table
? 导入数据（***掌握***）
当数据被加载至表中时，不会对数据进行任何转换。
Load 操作只是将数据复制/移动至 Hive 表对应的位置。
LOAD DATA [LOCAL] INPATH ‘filepath‘ [OVERWRITE]
INTO TABLE tablename
[PARTITION (partcol1=val1, partcol2=val2 ...)]
//把一个Hive表导入到另一个已建Hive表
INSERT OVERWRITE TABLE tablename [PARTITION (partcol1=val1, partcol2=val2 ...)] select_statement FROM from_statement
CTAS
CREATE [EXTERNAL] TABLE [IF NOT EXISTS] table_name
(col_name data_type, ...) …
AS SELECT …
例：create table new_external_test as select * from external_table1;
? 查询（***掌握***）
l 基于Partition的查询
一般 SELECT 查询是全表扫描。但如果是分区表，查询就可以利用分区剪枝（input pruning）的特性，类似“分区索引“”，只扫描一个表中它关心的那一部分。Hive 当前的实现是，只有分区断言（Partitioned by）出现在离 FROM 子句最近的那个WHERE 子句中，才会启用分区剪枝。例如，如果 page_views 表（按天分区）使用 date 列分区，以下语句只会读取分区为‘2008-03-01’的数据。
SELECT page_views.* FROM page_views WHERE page_views.date >= ‘2013-03-01‘ AND page_views.date <= ‘2013-03-01‘
l LIMIT Clause
Limit 可以限制查询的记录数。查询的结果是随机选择的。下面的查询语句从 t1 表中随机查询5条记录：
SELECT * FROM t1 LIMIT 5
l Top N查询
下面的查询语句查询销售记录最大的 5 个销售代表。
SET mapred.reduce.tasks=1
SELECT * FROM sales SORT BY amount DESC LIMIT 5
? 表连接（***了解***）
导入ac信息表
hive> create table acinfo (name string,acip string) row format delimited fields terminated by ‘\t‘ stored as TEXTFILE;
hive> load data local inpath ‘/home/acinfo/ac.dat‘ into table acinfo;
内连接
select b.name,a.* from dim_ac a join acinfo b on (a.ac=b.acip) limit 10;
左外连接
select b.name,a.* from dim_ac a left outer join acinfo b on a.ac=b.acip limit 10;
? UDF(用户自定义函数）（****必须掌握***）
1、UDF函数可以直接应用于select语句，对查询结构做格式化处理后，再输出内容。
2、编写UDF函数的时候需要注意一下几点：
1．自定义UDF需要继承org.apache.hadoop.hive.ql.UDF。
2．需要实现evaluate函数，evaluate函数支持重载。
AreaUDF.java
package cn.itcas.hive.udf;
import java.util.HashMap;
import java.util.Map;
import org.apache.hadoop.hive.ql.exec.UDF;
import org.apache.hadoop.io.Text;
public class AreaUDF extends UDF{
private static Map<Integer, String> areaMap = new HashMap<Integer, String>();
static {
areaMap.put(“guandong”, "广东");
areaMap.put(“beijing”, "北京");
areaMap.put(“shanghai”, "上海");
}
public Text evaluate(Text in){
String result = areaMap.get(Integer.parseInt(in.toString()));
if(result == null){
result = "其他";
}
return new Text(result);
}
}
准备数据：
1 wenge 36 guandong
2 kily 32 beijing
3 tomny 69 shanghai
4 laoli 38 guandong
创建表people
hive> create table people(id int,name string,age int,area string) ROW FORMAT DELIMITED FIELDS TERMINATED BY ‘\t‘;
加载数据
hive> load data local inpath ‘/root/people.dat‘ into table people;
4、步骤
1．把程序打包jar file :arearun.jar放到目标机器/root/arearun.jar上去；
2．进入hive客户端，添加jar包：hive> add jar /root/arearun.jar;
3．创建临时函数：hive> CREATE TEMPORARY FUNCTION getArea AS ‘cn.itcast.hive.udf.AreaUDF‘;
4．查询HQL语句：
hive> select id,name,age, getArea(area) from people;
5．销毁临时函数：hive> DROP TEMPORARY FUNCTION add_getArea;
注：UDF只能实现一进一出的操作，如果需要实现多进一出，则需要实现UDAF
? 总结：
基于Hadoop的大数据的计算/扩展能力
支持SQL like查询语言
统一的元数据管理
简单编程
2.Hbase
官方文档：http://abloz.com/hbase/book.html
? HBase简介（****了解***）
HBase – Hadoop Database，是一个高可靠性、高性能、面向列、可伸缩的分布式存储系统，利用HBase技术可在廉价PC Server上搭建起大规模结构化存储集群。HBase利用Hadoop HDFS作为其文件存储系统，利用Hadoop MapReduce来处理HBase中的海量数据，利用Zookeeper作为协调工具。
主键：Row Key
l 主键是用来检索记录的主键，访问hbase table中的行。
只有三种方式：
1．通过单个row key访问
2．通过row key的range
3．全表扫描
列族：Column Family
l 列族在创建表的时候声明，一个列族可以包含多个列，列中的数据都是以二进制形式存在，没有数据类型。
时间戳：timestamp
l HBase中通过row和columns确定的为一个存贮单元称为cell。每个 cell都保存着同一份数据的多个版本。版本通过时间戳来索引。
? Hbase搭建（***掌握****）
l 单节点模式搭建：(只适用学习环境）
1.解压hbase到/itcast目录下：
tar -zxvf hbase-0.96.2-hadoop2-bin.tar.gz -C /itcast/
2.修改${HBASE_HOME}/conf/两个配置文件
# vim hbase-env.sh
export JAVA_HOME=/usr/java/jdk1.7.0_79 //去掉注释改成本机的jdk
# vim hbase-site.xml
<configuration>
<!-- 指定hbase在HDFS上存储的路径 -->
<property>
<name>hbase.rootdir</name>
<value>file:///itcast/hbase-0.96.2-hadoop2/hbase</value>
</property>
</configuration>
3.启动hbase
# cd /itcast/hbase-0.96.2-hadoop2/bin
# ./start-hbase.sh
l 集群模式搭建：（合适大型应用） （在resourceManager1机器上）
1.上传hbase安装包hbase-0.96.2-hadoop2-bin.tar.gz
2.解压
tar -zxvf hbase-0.96.2-hadoop2-bin.tar.gz -C /itcast/
3.配置hbase集群，要修改3个文件（首先zk集群已经安装好了）
注意：要把hadoop的hdfs-site.xml和core-site.xml 放到hbase/conf下
# cp /itcast/hadoop-2.4.1/etc/hadoop/{hdfs-site.xml,core-site.xml}
/itcast/hbase-0.96.2-hadoop2/conf/
3.1修改hbase-env.sh
# vim /itcast/hbase-0.96.2-hadoop2/conf/hbase-env.sh
export JAVA_HOME=/usr/java/jdk1.7.0_79
//告诉hbase使用外部的zk
export HBASE_MANAGES_ZK=false
# vim /itcast/hbase-0.96.2-hadoop2/conf/hbase-site.xml
<configuration>
<!-- 指定hbase在HDFS上存储的路径 -->
<property>
<name>hbase.rootdir</name>
<value>hdfs://ns1/hbase</value>
</property>
<!-- 指定hbase是分布式的 -->
<property>
<name>hbase.cluster.distributed</name>
<value>true</value>
</property>
<!-- 指定zk的地址，多个用“,”分割 -->
<property>
<name>hbase.zookeeper.quorum</name>
<value>zookeeperServer1:2181,zookeeperServer2:2181,zookeeperServer3:2181</value>
</property>
</configuration>
<!--修改regionservers文件,配置那下面几台机器为regionserver-->
# vim /itcast/hbase-0.96.2-hadoop2/conf/regionservers
zookeeperServer1
zookeeperServer2
zookeeperServer3
3.2拷贝hbase到其他节点
scp -r /itcast/hbase-0.96.2-hadoop2/ zookeeperServer1:/itcast/
scp -r /itcast/hbase-0.96.2-hadoop2/ zookeeperServer2:/itcast/
scp -r /itcast/hbase-0.96.2-hadoop2/ zookeeperServer3:/itcast/
scp -r /itcast/hbase-0.96.2-hadoop2/ nameNode1:/itcast/
scp -r /itcast/hbase-0.96.2-hadoop2/ nameNode2:/itcast/
scp -r /itcast/hbase-0.96.2-hadoop2/ resourceManager2:/itcast/
4.将配置好的HBase拷贝到每一个节点并同步时间。
Linux时间同步(把nameNode1作为时间同步服务器）
设置时区
cp /usr/share/zoneinfo/Asia/Shanghai /etc/localtime
联网情况：ntpdate us.pool.ntp.org
查看NTP状态
service ntpd status
yum install ntpd
chkconfig ntpd on
配置ntp服务端：
vim /etc/ntp.conf
restrict 192.168.0.0 mask 255.255.255.0 nomodify notrap
server 127.127.1.0 # local clock
fudge 127.127.1.0 stratum 10
保存退出
service ntpd restart
客户端：
注掉与Internet通信的Server，使用本地时钟
server 192.168.0.101
在所有子节点上执行命令手动同步时间
ntpdate 192.168.0.101
service ntpd restart
5.启动所有的hbase
分别启动zk
./zkServer.sh start
启动hbase集群
start-dfs.sh
启动hbase，在主节点上运行：
/itcast/hbase-0.96.2-hadoop2/bin/start-hbase.sh
关闭hbase,在主节点上运行：
/itcast/hbase-0.96.2-hadoop2/bin/stop-hbase.sh
6.通过浏览器访问hbase管理页面
7.为保证集群的可靠性，要启动多个HMaster
/itcast/hbase-0.96.2-hadoop2/bin/hbase-daemon.sh start master //开启
/itcast/hbase-0.96.2-hadoop2/bin/hbase-daemon.sh stop master //关闭
? Hbase表结构（***理解***）
主键：Row Key
l 主键是用来检索记录的主键，访问hbase table中的行。
只有三种方式：
4．通过单个row key访问
5．通过row key的range
6．全表扫描
列族：Column Family
l 列族在创建表的时候声明，一个列族可以包含多个列，列中的数据都是以二进制形式存在，没有数据类型。
时间戳：timestamp
l HBase中通过row和columns确定的为一个存贮单元称为cell。每个 cell都保存着同一份数据的多个版本。版本通过时间戳来索引。
? 物理存储（****理解*****）
HBase中有两张特殊的Table，-ROOT-和.META.
l -ROOT- ：记录了.META.表的Region信息，
l .META. ：记录了用户创建的表的Region信息，.META.可以有多个regoin
Zookeeper中记录了-ROOT-表的location
Client访问用户数据之前需要首先访问zookeeper，然后访问-ROOT-表，接着访问.META.表，最后才能找到用户数据的位置去访问。
? Hbase架构体系（***理解***）
l Client
包含访问hbase 的接口，client 维护着一些cache 来加快对hbase 的访问，比如regione 的位置信息
l Zookeeper
1．保证任何时候，集群中只有一个running master
2．存贮所有Region 的寻址入口
3．实时监控Region Server 的状态，将Region server 的上线和下线信息，实时通知给Master
4．存储Hbase 的schema,包括有哪些table，每个table 有哪些column family
l Master 可以启动多个HMaster
通过Zookeeper的Master Election机制保证总有一个Master运行
为Region server 分配region
负责region server 的负载均衡
发现失效的region server 并重新分配其上的region
l Region Server
维护Master 分配给它的region，处理对这些region 的IO 请求
负责切分在运行过程中变得过大的region
可以看出，client 访问hbase 上数据的过程并不需要master 参与，寻址访问先zookeeper再regionserver，数据读写访问regioneserver。HRegionServer主要负责响应用户I/O请求，向HDFS文件系统中读写数据，是HBase中最核心的模块。
? Hbase shell命令（***掌握***）
解决shell终端不能退格的问题：
在SecureCRT ---->“选项”--->“会话选项”如图
在仿真选项里选择终端为linux,在映射键里选择 Backspace发送delete.单击确定就可以用退格键了。
hbase提供了一个shell的终端给用户交互
命令所在路径：
${HBASE_HOME}/bin/hbase shell
进入hbase命令行
./hbase shell
显示hbase中的表
list
创建user表，包含base_info、extra_info两个列族
create ‘user‘,{NAME => ‘base_info‘,VERSIONS => 3},{ NAME => ‘extra_info‘}
查看表结构
describe ‘user‘
删除user表(注意要先disable表才能删除）
disable ‘user‘
drop ‘user‘
向user表中插入信息，row key为‘0001‘，列族base_info中添加name列标示符，值为zhangsan
put ‘user‘,‘0001‘,‘base_info:name‘,‘zhangsan‘
向user表中插入信息，row key为‘0001‘，列族extra_info中添加name列标示符，值为‘lixi‘
put ‘user‘,‘0001‘,‘extra_info:name‘,‘lixi‘
查询‘user‘表，row key为‘0001‘的信息
get ‘user‘,‘0001‘
更新表‘user‘，row key为‘0001‘，列族base_info中添加name列标示符，值为‘zhangsan2‘
put ‘user‘,‘0001‘,‘base_info:name‘,‘zhangsan2‘
put ‘user‘,‘0001‘,‘base_info:name‘,‘zhangsan3‘
put ‘user‘,‘0001‘,‘base_info:name‘,‘zhangsan4‘
新旧表的信息同时找出来（如果插入比VERSIONS=3更多的列会不保存）
get ‘user‘,‘0001‘,{COLUMN => ‘base_info:name‘,VERSIONS => 10}
用scan查询
scan ‘user‘
把过时版本显示出来
scan ‘user‘,{RAW => true, VERSIONS => 10}
? Hbase的Java API（***掌握****）
新建eclipse工程,并导入hbase的jar包：${HBASE_HOME}/lib/*
执行hbase shell初始化数据：
//创建accout表
create ‘account‘, {NAME => ‘base_info‘}
HbaseDemo.java
package cn.itcast.hbase;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.hbase.KeyValue;
import org.apache.hadoop.hbase.client.Get;
import org.apache.hadoop.hbase.client.HBaseAdmin;
import org.apache.hadoop.hbase.client.HTable;
import org.apache.hadoop.hbase.client.Put;
import org.apache.hadoop.hbase.client.Result;
import org.apache.hadoop.hbase.util.Bytes;
import org.junit.Before;
import org.junit.Test;
public class HbaseDemo {
private Configuration conf = null;
@Before
public void init(){
conf = HBaseConfiguration.create();
conf.set("hbase.zookeeper.quorum", "zookeeperServer1:2181,zookeeperServer2:2181,zookeeperServer3:2181");
}
@Test
public void testDrop() throws Exception{
HBaseAdmin admin = new HBaseAdmin(conf);
admin.disableTable("account");
admin.deleteTable("account");
admin.close();
}
/**
* @throws Exception
*/
@Test
public void testPut() throws Exception{
HTable table = new HTable(conf, "account");
Put put = new Put(Bytes.toBytes("0001"));
put.add(Bytes.toBytes("base_info"), Bytes.toBytes("name"), Bytes.toBytes("liuyan"));
table.put(put);
table.close();
}
@Test
public void testGet() throws Exception{
HTable table = new HTable(conf, "account");
Get get = new Get(Bytes.toBytes("0001"));
get.setMaxVersions(5);
Result result = table.get(get);
for(KeyValue kv : result.list()){
String family = new String(kv.getFamily());
System.out.println(family);
String qualifier = new String(kv.getQualifier());
System.out.println(qualifier);
System.out.println(new String(kv.getValue()));
}
table.close();
}
}
? 思考：
l HBASE是什么数据库，与普通RDBMS有什么区别
l HBASE的结构
l HBASE的常用命令