hbase

1.介绍

base适合存储PB级别的海量数据，在PB级别的数据以及采用廉价PC存储的情况下，能在几十到百毫秒内返回数据。这与Hbase的极易扩展性息息相关。正是因为Hbase良好的扩展性(存储在HDFS)，才为海量数据的存储提供了便利。

特点

1.海量存储：适合存储PB级别的海量数据
2.列式存储：列族存储，Hbase是根据列族来存储数据的。列族下面可以有非常多的列，列族在创建表的时候就必须指定。
3.极易扩展：Hbase的扩展性主要体现在两个方面，一个是基于上层处理能力（RegionServer）的扩展，一个是基于存储的扩展（HDFS）（通过横向添加RegionSever的机器，进行水平扩展，提升Hbase上层的处理能力，提升Hbsae服务更多Region的能力。）
4.高并发：由于目前大部分使用Hbase的架构，都是采用的廉价PC，因此单个IO的延迟其实并不小，一般在几十到上百ms之间。这里说的高并发，主要是在并发的情况下，Hbase的单个IO延迟下降并不多。能获得高并发、低延迟的服务。
5.稀疏：稀疏主要是针对Hbase列的灵活性，在列族中，你可以指定任意多的列，在列数据为空的情况下，是不会占用存储空间的。

HBASE的应用场景

不适合：需要数据分析，比如报表。 因为会存在行数据不完整情况
	   单表数据在千万级别以下
适合： 单表唱过千万，并发量很高，数据分析需求弱，或者不需要那么灵活和实时。

2.HBASE架构

HBASE: 弱化HMaster功能，让HMaster管理多个RegionServer.元数据在HMaster中。将元数据注册到zookepeer中，客户端访问时候直接访问zookepeer。如果HMaster宕机，我们从zookepeer中拿取元数据，然后通过元数据去RegionServer拿到数据。所以当HMaster宕机是不影响整个过程。HBASE安装需要zookepeer工具提供。

3.安装

安装前提：hdfs zookepeer已经安装完毕。
下载hbase
解压
```
tar -zxvf hbase-1.2.6-bin.tar.gz 
```

更改conf下hbase-env.sh环境

cd hbase-1.2.6/conf/
vim hbase-env.sh
	export JAVA_HOME=/usr/lib/jvm/jre-1.8.0-openjdk-1.8.0.262.b10-0.el7_8.x86_64/
	# 将内部的zookepeer关掉，使用自己的
	export HBASE_MANAGES_ZK=false

配置hbase-site.xml 文件

vim hbase-site.xml 

<configuration>
<!-- 指定hbase在HDFS上存储的路径 -->
<property>
<name>hbase.rootdir</name>
<value>hdfs://linux01:9000/hbase</value>
</property>
<!-- 指定hbase是分布式的 -->
<property>
<name>hbase.cluster.distributed</name>
<value>true</value>
</property>
<!-- 指定zk的地址，多个用“,”分割 -->
<property>
<name>hbase.zookeeper.quorum</name>
<value>linux01:2181,linux02:2181,linux03:2181</value>
</property>
</configuration>

配置regionserver 集群的机器
```
linux01
linux02
linux03
```
时间同步，HBASE数据同步，时间要求一致

配置HBASE环境变量

vim /etc/profile
export HBASE_HOME=/opt/hdp/hbase-1.2.6
export PATH=$HADOOP_HOME/sbin:$HBASE_HOME/bin
source /etc/profile

安装完的hbase分发linux02 linux03

scp -r hbase-1.2.6 linux02:$PWD
scp -r hbase-1.2.6 linux03:$PWD

启动zookepeer

/opt/zookeeper-3.4.6/bin/zkServer.sh start /opt/zookeeper-3.4.6/conf/zoo.cfg

启动dfs
```
[root@linux01 bin]# start-dfs.sh
```
linux01---->master启动hbase
```
hbase-daemon.sh start master
```
启动linux01 regionserver
```
hbase-daemon.sh start regionserver
```
输入网址http://10.0.0.134:16010/master-status如下图启动完毕
在linux02启动master,会将其作为备用master
```
hbase-daemon.sh start master
```

单节点启动

# region停止
hbase-daemon.sh stop regionserver
# region启动
hbase-daemon.sh start regionserver
# master停止
hbase-daemon.sh stop master
# master启动
hbase-daemon.sh start master

一键启停

会加载regionservers文件配置的节点启动resionserver
start-hbase.sh
stop.hbase.sh

注意出现如下警告：

![image-20210115182522469](C:\Users\Xu jk\AppData\Roaming\Typora\typora-user-images\image-20210115182522469.png)

解决：
vim /opt/hdp/hbase-1.2.6/conf/hbase-env.sh 

删除如下两行：
export HBASE_MASTER_OPTS="$HBASE_MASTER_OPTS -XX:PermSize=128m -XX:MaxPermSize=128m"
export HBASE_REGIONSERVER_OPTS="$HBASE_REGIONSERVER_OPTS -XX:PermSize=128m -XX:MaxPermSize=128m"
# 仅仅是针对JDK7    JDK8中做了优化。所以这两行可以删除

如果启动失败：1检查时间是否同步，2检查zookepeer和hdfs是否启动成功

4.HBase表模型

hbase的表模型跟mysql之类的关系型数据库的表模型差别巨大.
hbase的表模型种有:行的概念,列族的概念,但没有字段的概念.
行种村的都是key-value对,每行种的key-value对中的key可以是各种各样的,每行中的key-value对的数量也可以是各种各样.
Hbase表模型要点:

1.一个表,有表名
2.一个表可以分为多个列族.(不同列族的数据会存储在不同文件中)
3.表中的每一行有一个 "行键rowkey" 行键在表中不能重复(类似mysql主键),它是定长的.
4.表中每一对kv数据称位一个cell
5.hbase可以对数据存储多个历史版本(历史版本数量可配置)
6.整张表由于数据量过大,会被横向切分成若干个region(用rowkey范围标识),不同region数据也存储在不同文件中.
7.hbase会对插入数据按顺序存储.
存储示例:
	rowkey|columnFamily|key|value
而且hbase会对存入的keyvalue数据自动排序,排序规则如下:
	先按行键,再按列族名,再按key名 进行排序(字典顺序逐,字节比较)

如下图:
hbase连接客户端
```
hbase shell
```

xshell配置(xshell操作客户端无法删除,需要对xshell配置)

文件 -->属性-->终端-->键盘 
在 DELETE键序列  和 BACKSPACE键序列 中都选择  ASCII 127

5.Hbase存储数据类型

全是二进制

6.shell命令

基本命令

1.查看版本
version
2.查看hbase的状态
staus
3.查看当前用户信息
whoami
4.查看表的帮助信息
table_help

创建表（必须指定列族）

# 创建tb_user表,列族为info
create 'tb_user' , 'info'
create 'tb_user2' , 'info1', 'info2'

list查看所有表名

hbase(main):010:0> list
TABLE                 
tb_user                      
1 row(s) in 0.0530 seconds
=> ["tb_user"]

# 正则查询（匹配tb开头的表）
list "tb.*"

查看表详情

hbase(main):012:0> desc 'tb_user'
Table tb_user is ENABLED     #表示可用的            
tb_user                         
COLUMN FAMILIES DESCRIPTION                       
{NAME => 'info', BLOOMFILTER => 'ROW', VERSIONS => '1', IN_MEMORY => 'false', KEEP_DELETED
_CELLS => 'FALSE', DATA_BLOCK_ENCODING => 'NONE', TTL => 'FOREVER', COMPRESSION => 'NONE',
 MIN_VERSIONS => '0', BLOCKCACHE => 'true', BLOCKSIZE => '65536', REPLICATION_SCOPE => '0'
}                       
1 row(s) in 4.2550 seconds

# 字段意义
NAME 列族名
TTL 过期时间
BLOCKSIZE 大小

插入数据(更新)

put 'tb_user' , 'rowkey001' , 'info:age', 25
put 'tb_user' , 'rowkey001' , 'info:name' , 'ming'
	 表名		    行键	    列族:属性(列) 	值

扫描表的内容

# 扫描全表的内容
hbase(main):019:0> scan "tb_user"
ROW                     COLUMN+CELL                                                       
 rowkey001              column=info:age, timestamp=1610722955208, value=25                
 rowkey001              column=info:name, timestamp=1610722885973, value=ming             
1 row(s) in 0.0250 seconds
# 显示tb_user前2行数据
scan "tb_user" , {LIMIT=>2}
# 显示tb_user前2行数据 从rowkey002开始
scan "tb_user" , {STARTROW=>'rowkey002',LIMIT=>2}
# 显示tb_user 从 rowkey002 到 rowkey005 数据 不包含rowkey005
scan "tb_user" , {STARTROW=>'rowkey002',STOPROW=>"rowkey005"}

内存数据刷新到磁盘：（当内存到128M也会自动刷入数据）

hbase(main):027:0> flush 'tb_user'

get获取数据

# 获取表tb_user 键为rowkey001数据
get "tb_user" , "rowkey001"
# 获取表tb_user 键为rowkey001的name数据
get "tb_user" , "rowkey001" , "info:name"
# 获取表tb_user 键为rowkey001，列族info的数据
get "tb_user" , "rowkey001" , "info"

添加列族

# tb_user表下新增info2列族
alter "tb_user" , "info2"

删除列族

alter "tb_user" ,"delete"=> "info2"

删除某个value

delete "tb_user2", "rowkey002" , "info2:name"

清空表

disable "tb_user2"

停用表

disable "tb_user2"

查看表是否停用

is_disabled "tb_user2"

删除所有表

# 删除tb开头表
drop_all "tb.*"

停用多个表

# 停用tb开头表
disable_all "tb.*"

删除表

drop "tb_user2"
# 删除表前先将表停用

启用一张表

enable "tb_user2"

创建快照

# 将tb_user2 新建名为info快照
snapshot "tb_user2", "info"

查看快照

list_snapshots

恢复快照

# 先禁用
disable "tb_user"
restore_snapshot "info"   #info为快照名
enable "tb_user"
scan "tb_user"

克隆数据到新表

clone_snapshot "info" , "t_test2"
			  快照名     表名（新表没有创建过的）

显示表有多少个数据

count "tb_user2"

判断表是否存在

exists "tb_user2"

查看列族存储数据region所在机器

locate_region "tb_user", "info"

7.hfile store flush

原理

我们知道数据存储在RegionServer 中，当一个RegionServer存储数据是有限制的，一旦超出限制会对数据进行拆分，存储到其他机器中(Regionserver)中,当然一个RegionServer内有多个Region (比如有user表，order表...),数据真正存储在Store（Store可以认为是一个列族）中，刚开始数据不到128M会存储在内存中（memStore,memStore可以有效帮助我们提高查询速度）,而数据在内存中一旦宕机可能会引起数据丢失，通过日志（logfile）可解决此问题。它会先写在一个叫Write-Ahead logfile的文件中，然后再写到内存中。一旦数据占用空间到128M会flush刷入文件(HFile)中.当然你也可以人为去flush，所有的关键在于rowKey范围，rowKey范围决定了我们数据存储在不同机器上,如果rowkey设计不合理，则会导致数据倾向。



其内部优化：当你执行大量flush会形成大量小文件，它的内部会进行文件合并，同样当你进行大量删除，它也会进行相同操作。

8.Hbase JavaApi

package xjk.com.hbase;

import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

import org.apache.hadoop.hbase.client.Table;
import org.apache.hadoop.hbase.util.Bytes;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.Cell;
import org.apache.hadoop.hbase.CellUtil;
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.Admin;
import org.apache.hadoop.hbase.client.Connection;
import org.apache.hadoop.hbase.client.ConnectionFactory;
import org.apache.hadoop.hbase.client.Delete;
import org.apache.hadoop.hbase.client.Get;
import org.apache.hadoop.hbase.client.Put;
import org.apache.hadoop.hbase.client.Result;
import org.apache.hadoop.hbase.client.ResultScanner;
import org.apache.hadoop.hbase.client.Scan;

public class TestClient {
	static Connection conn = null;
	static {
		try {
			// 创建初始化的配置对象
			Configuration conf = HBaseConfiguration.create();
			// 设置ZK集群位置
			conf.set("hbase.zookeeper.quorum", "10.0.0.134:2181,10.0.0.131:2181,10.0.0.132:2181");
			// 获取连接对象
			conn  = ConnectionFactory.createConnection(conf);
			// 管理对象  对表操作
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	/*
	 *  判断表是否存在
	 * @param tbName 表名
	 * */
	public static boolean tableExists(String tbName) throws Exception {
		Admin admin = conn.getAdmin();
		return admin.tableExists(TableName.valueOf(tbName));
	}
	/*
	 * 创建表
	 *   @param tbName 表名
	 * 	  @param cfs  String ... 方法可变参数:列族
	 * */
	public static void createTable(String tbName, String ...cfs) throws Exception {
		Admin admin = conn.getAdmin();
		if (!tableExists(tbName)) {
			// 创建表描述对象
			HTableDescriptor tbd = new HTableDescriptor(TableName.valueOf(tbName));
			// 遍历创建列族
			for (String cf : cfs) {
				HColumnDescriptor family = new HColumnDescriptor(cf.getBytes());
				// 添加列族
				tbd.addFamily(family);
			}
			// 生成表
			admin.createTable(tbd);
			System.out.println(tbName + "创建成功");
		} else {
			System.out.println(tbName + "表已经存在");
		}
	}
	/*
	 * 删除表
	 *   @param tbName 表名
	 * */
	public static void deleteTable(String tbName) throws Exception {
		Admin admin = conn.getAdmin();
		if (tableExists(tbName)) {
			// 禁用表
			admin.disableTable(TableName.valueOf(tbName));
			admin.deleteTable(TableName.valueOf(tbName));
			System.out.println("删除" + tbName + "成功");
		} else {
			System.out.println("删除" + tbName + "失败");
		}
	}
	/*
	 * 添加一行数据 (windows本地要配置hosts文件否则插入数据阻塞)
	 *   @param tbName 表名
	 *   @param rk 行键
	 *   @param cf 列族
	 *   @param key 键
	 *   @param value 值
	 * */
	public static void addValue(String tbName, String rk, String cf, String key, String value) throws Exception {
		Table table = conn.getTable(TableName.valueOf(tbName));
		Put put = new Put(rk.getBytes());;
		// 参数1:列族， 参数2:key  参数3:value
		put.addColumn(cf.getBytes(), key.getBytes(), value.getBytes());
		table.put(put);
		System.out.println("创建数据成功");
	}
	/*
	 * 查询获取表数据(按照行范围)
	 *   @param tbName 表名
	 * */
	public static void getAllData(String tbName, String start, String end) throws Exception {
		Table table = conn.getTable(TableName.valueOf(tbName));
		// 创建Scan对象
		Scan scan = new Scan();
		// 设置起始行
		scan.setStartRow(Bytes.toBytes(start));
		// 设置结束行(不包含当前行)
		scan.setStopRow(Bytes.toBytes(end));
		// 将数据转换成字节
		// byte[] bytes = Bytes.toBytes("");
		// 全表扫描
		ResultScanner scanner = table.getScanner(scan);
		// 遍历每行单元格
		for (Result result : scanner) {
			// 获取行单元格 行的单元格个数不一定一致
			Cell[] rawCells = result.rawCells();
			for (Cell cell: rawCells) {
				// 行键
				System.out.print(new String(CellUtil.cloneRow(cell)) + "--");
				//  列族
				System.out.print(new String(CellUtil.cloneFamily(cell)) + "--");
				//  键(属性)
				System.out.print(new String(CellUtil.cloneQualifier(cell)) + "--");
				//  值
				System.out.print(new String(CellUtil.cloneValue(cell)));
				System.out.println();
			}
		}
	}
	public static void addValues(String tbName, String rk, String cf, String key, String value) throws Exception {
		Table table = conn.getTable(TableName.valueOf(tbName));
		Put put2 = new Put(rk.getBytes());
		// 参数1:列族， 参数2:key  参数3:value
		put2.addColumn(cf.getBytes(), key.getBytes(), value.getBytes());
		List<Put> list = new ArrayList<>();
		list.add(put2);
		table.put(list);
		System.out.println("创建数据成功");
	}
	/*
	 * 查询表的某个行的列族数据
	 *   @param tbName 表名
	 *   @param rk 行键
	 *   @param cf 列族
	 * */
	public static void getDataByRkAndCf(String tbName, String rk, String cf) throws Exception {
		Table table = conn.getTable(TableName.valueOf(tbName));
		// 获取行get对象
		Get get = new Get(rk.getBytes());
		// 指定列族
		get.addFamily(cf.getBytes());
		Result result = table.get(get);
		Cell[] rawCells = result.rawCells();
		// 遍历
		for (Cell cell : rawCells) {
			// 行键
			System.out.print(new String(CellUtil.cloneRow(cell)) + "--");
			//  列族
			System.out.print(new String(CellUtil.cloneFamily(cell)) + "--");
			//  键(属性)
			System.out.print(new String(CellUtil.cloneQualifier(cell)) + "--");
			//  值
			System.out.print(new String(CellUtil.cloneValue(cell)));
			System.out.println();
		}
	}
	/*
	 * 查询某个具体属性值
	 *   @param tbName 表名
	 *   @param rk 行键
	 *   @param cf 列族
	 *   @param cf 键
	 * */
	public static void getDataByKey(String tbName, String rk, String cf, String key) throws Exception {
		Table table = conn.getTable(TableName.valueOf(tbName));
		Get get = new Get(rk.getBytes());
		// 设置列族和属性
		get.addColumn(cf.getBytes(), key.getBytes());
		Result result = table.get(get);
		Cell[] rawCells = result.rawCells();
		// 遍历
		for (Cell cell : rawCells) {
			// 行键
			System.out.print(new String(CellUtil.cloneRow(cell)) + "--");
			//  列族
			System.out.print(new String(CellUtil.cloneFamily(cell)) + "--");
			//  键(属性)
			System.out.print(new String(CellUtil.cloneQualifier(cell)) + "--");
			//  值
			System.out.print(new String(CellUtil.cloneValue(cell)));
			System.out.println();
		}
	}
	/*
	 * 删除某个行数据
	 *   @param tbName 表名
	 *   @param rk 行键
	 * */
	public static void deleteByRow(String tbName,String rk) throws Exception {
		Table table = conn.getTable(TableName.valueOf(tbName));
		Delete d = new Delete(rk.getBytes());
		table.delete(d);
	}
	/*
	 * 删除多个行数据
	 *   @param tbName 表名
	 *   @param rk 行键
	 * */
	public static void deleteByRows(String tbName,String... rks) throws Exception {
		Table table = conn.getTable(TableName.valueOf(tbName));
		List <Delete> list = new ArrayList<>();
		for (String rk : rks) {
			Delete d = new Delete(rk.getBytes());
			list.add(d);
		}
		table.delete(list);
	}
	public static void main(String[] args) throws Exception {
		// 判断表是否存在
		//	 System.out.println(tableExists("tb_user"));
		// 创建表
        //	 createTable("demo2", "info1","info2");
		// 删除表
        //	 deleteTable("demo2");
		// 创建数据
		// addValue("demo2", "rowkey005", "info1", "address", "beijing");
		// 获取全表数据
		 // getAllData("demo2", "rowkey002", "rowkey004");
		 // 查询表的某个行的列族数据
		 // getDataByRkAndCf("demo2", "rowkey002", "info1");
		// 查询某个具体属性值
		 // getDataByKey("demo2", "rowkey002", "info1", "name");
		// 删除行数据
		// deleteByRow("demo2", "rowkey005");
		// 删除多个行数据
		deleteByRows("demo2", "rowkey004", "rowkey003");
	}
}

9.过滤器

基础API中查询操作在面对大数据时候比较苍白，这里Hbase提供高级的查询方法：Filter，它可以根据簇，列，版本等更多的条件来对数据进行过滤，基于Hbase本身提供三维有序（主键有序，列有序，版本有序），这些Filter可以高效完成查询过滤的任务，带有Filter条件的RPC查询请求会把Filter分发各个RegionServer,是一个服务端的过滤器，这样可以降低网络传输的压力。
要完成一个过滤的操作，至少需要两个参数，一个是抽象的操作复，Hbase提供了枚举类型的变量来标识这些抽象操作符：LESS/LESS_OR_EQUAL/EQUAL/NOT_EQUAL等。另外一个就是具体的比较器。代表具体的比较逻辑，如可以提高字节级的比较，字符串级比较等，有了这两个参数，我们就可以清除的定义筛选的条件，过滤数据。

抽象操作符（比较运算符）

LESS <
LESS_OR_EQUAL <=
EQUAL =
NOT_EQUAL <>
GREATER_OR_EQUAL >=
GREATER >
NO_OP 排除所有

比较器（指定比较机制）

BinaryComparator 按字节索引顺序比较指定字节数组，采用 Bytes.compareTo(byte[])
BinaryPrefixComparator 跟前面相同，只是比较左端的数据是否相同
NullComparator 判断给定是否为空
BitComparator 按位比较
RegexStringComparator 提供一个正则的比较器 仅支持EQUAL 和 非EQUAL
SubstringComparator 判断提供的子串是否出现在value中

过滤器种类：

行过滤器

过滤 判断子串行键是否包含rk
Filter filter = new RowFilter(CompareOp.EQUAL, new SubstringComparator("rk"));

列族过滤器

Filter filter = new FamilyFilter(CompareOp.EQUAL, new BinaryComparator("info1".getBytes()));

列过滤器（属性 key过滤）

Filter filter = new QualifierFilter(CompareOp.EQUAL, new BinaryComparator("age".getBytes()));

值过滤器

Filter filter = new ValueFilter(CompareOp.EQUAL, new BinaryComparator("xjk".getBytes()));

单列过滤器
- 返回符合条件的整行数据和没有此属性的行

Filter filter = new SingleColumnValueFilter("info2".getBytes(), "name".getBytes(),CompareOp.EQUAL, new BinaryComparator("xjk".getBytes()));

针对行键

//rk开头
Filter filter = new PrefixFilter("rk".getBytes());

列前缀

// 所有有name的列（key）
Filter filter = new ColumnPrefixFilter("name".getBytes());

10.读写数据流程

读取数据

master注册元数据到zookpeer,客户端请求去zookepeer找到元数据，然后根据元数据去找到对应存储数据的region，在region中先从内存中找(memStore),没有找到会再去缓存中找(CacheStore),缓存中没有才会去文件中找(HFile),当从HFile找到数据时候，它会将找到数据再放到CacheStore,下次找的时候更快。当然缓存中保存数据方式是堆外内存，因为堆内内存会存在溢出现象，但堆外内存不好管理，它内部做了一个优化-->（堆外内存+固态磁盘内存）。

写数据

向hbase表中添加数据，首先master将元数据注册到zookepeer中，master管理着多个RegionServer,master中有一个meta它记录每张表存储范围。  当客户端向zookepeer请求写操作,会返回meta,meta告诉往哪写，客户端会往region写数据，而region会有Hlog,Hlog会操作HDFS客户端进行持久化操作。同时数据也往内存中写(memstore),当你文件到达128M时候会触发flush。flush会生成一个HFile,生成HFile操作HDFS客户端进行持久化。当HDFS将数据持久化后，它会将刷新成功后数据的Hlog记录删掉。将当然一个Region有多个列族(Store),

因HDFS不支持随机访问，所有数据都是写操作(追加)，当你执行删除，也是执行添加操作，
	# put rk001 "abc"
	# 删除： rk001 "" [delete]
***当我们执行查询时候，发现会根据墓碑标记的数据，进行合并。修改操作特使一样会维护内部一个版本。

11 row设计的基本思路

设计要根据维度查询频率进行设计，设计rowkey要定长且唯一。比如如下：
```
我们对rowkey设计 (userID(6位) + time(8位) + fileID(6位))
000001 20180501 000001
000001 20180501 000002
000001 20180502 000003
000001 20180503 000003
000002 20180501 000001
000002 20180501 000002
...
当用户id相同我们可以根据用户 + 时间进行查询排序，当用户和时间相同我们可以进行用户+时间+文件id进行查询排序
```
在建立一个scan对象后，我们setStartRow(0000012018050 000001),setEndRow(000001 20180503 000003).这样，scan时只扫描userID=1的数据，且时间范围限定在这个指定时间段内，满足按用户以及按时间范围对结果的筛选，并且由于记录集中存储，性能会很好。

然后使用SingleColumnValueFilter 分别约束name的上下限，于category的上下限，满足按同时按文件名以及分类名的前缀匹配。

12.Phoenix整合hbase

Phoenix由saleforce.com开源的一个项目，后又捐给了Apache。它相当于一个Java中间件，帮助开发者像使用JDBC访问关系型数据库一样，访问NoSQL数据库HBase.

下载

http://phoenix.apache.org/download.html

安装：

tar -zxvf apache-phoenix-4.14.0-HBase-1.2-bin.tar.gz

将phoenix-4.14.0-HBase-1.2-server.jar赋值hbase 的lib下

cp phoenix-4.14.0-HBase-1.2-server.jar /opt/hdp/hbase-1.2.6/lib

将phoenix-4.14.0-HBase-1.2-server.jar 包发送给其他节点的lib目录下

scp phoenix-4.14.0-HBase-1.2-server.jar linux02:/opt/hdp/hbase-1.2.6/lib
scp phoenix-4.14.0-HBase-1.2-server.jar linux03:/opt/hdp/hbase-1.2.6/lib

重启HBASE
```
stop-hbase.sh
start-hbase.sh
```

连接phoenix

# 到 /root/apache-phoenix-4.14.0-HBase-1.2-bin/bin 目录下
# 连接
./sqlline.py 10.0.0.134,10.0.0.131,10.0.0.132:2181

这样你可以像操作mysql一样操作hbase了

常用指令

1.显示所有表
!table
2. 退出
!quit
3.查看表结构
!describe "表名"
4.创建表
create table user(name varchar not null primary key, age  varchar)salt_buckets=16;
5.插入数据
upsert into user values('liutao','25');
6.查询
select * from user;
7.删除
delete from user where name = 'liutao';

查询数据支持：union all， group by， order by， limit 都支持

13.Python操作hbase

Linux安装Thrift

yum安装依赖

yum install automake bison flex g++ git libboost1.55 libevent-dev libssl-dev libtool make pkg-config

解压thrift

tar -zxvf thrift-0.11.0.tar.gz
cd thrift-0.11.0

编译安装

./configure --with-cpp --with-boost --with-python --without-csharp --with-java --without-erlang --without-perl --with-php --without-php_extension --without-ruby --without-haskell  --without-go
make
make install

在Master中Hbase安装目录下bin目录启动thrift服务、
```
./hbase-daemon.sh start thrift
```
安装happybase包
```
pip install happybase
```

连接操作

# 9090端口是 hbase thrift启动默认端口
connection = happybase.Connection('10.0.0.134',port=9090)

DDL

简单示例

# 打印所有表名
import happybase
connection = happybase.Connection('10.0.0.134',port=9090)
# 获取所有表
table_name_list = connection.tables()
print(table_name_list)
connection.close()
# [b'SYSTEM.CATALOG', b'SYSTEM.FUNCTION', b'SYSTEM.LOG', b'SYSTEM.MUTEX', b'SYSTEM.SEQUENCE', b'SYSTEM.STATS', b'USER', b'demo2', b't_test1', b't_test2', b'tb_user', b'user2']

获取一个表对象

table = connection.table(name) 
# name表名
# user_prefix 是否使用表前缀，默认True

禁用表：删除前需要禁用表
```
connection.disable_table("USER")
```
启用表
```
connection.enable_table("USER")
```

创建表

family = {
	"info1": dict(),
	"info2": dict()
}
#参数1：表名   参数2：列族
connection.create_table("pyTest", family)

删除表

# 参数1：表名   参数2：是否先禁用
connection.delete_table("pyTest",disable=False)

DML

获取表实例：

connection.open()
table = connection.table("tb_user")

获取单元格cells

cells(row, column, versions=None, timestamp=None, include_timestamp=False)  # 获取单元格数据，返回一个byte的list
row：行
column：列
versions：获取的最大版本数量，默认None，即获取所有
timestamp：时间戳，默认None，即获取所有时间戳版本的数据。可指定一个时间戳，获取小于此时间戳版本的所有数据
include_timestamp：是否返回时间戳，默认False


e.g.:
connection.open()
table = connection.table("tb_user")
content = table.cells("rowkey001", "info:name")
print(content) # [b'ming']

删除指定行数据

delete(row, columns=None, timestamp=None, wal=True)：删除指定行数据，无返回值
row：行
columns：列，默认为None，即删除所有列，可传入一个list或tuple来指定删除列
timestamp：时间戳，默认为None，即删除所有，可传入一个时间戳来删除小于等于此时间戳的所有数据
wal：是否写入wal，默认为True

e.g.:
connection.open()
table = connection.table("tb_user")
# info为 列族  pwd为字段属性(key)
table.delete("rowkey001", columns=["info:pwd"])
connection.close()

插入数据

put(row, data, timestamp=None, wal=True)：插入数据，无返回值
row: 行
data: 数据，dict类型，{列:值}构成，列与值皆为str类型
timestamp：时间戳，默认None，即写入当前时间戳
wal：是否写入wal，默认为True

e.g.:
table.put("rowkey001", {"info:pwd":"123", "info:sex": "man"})

获取一行数据

row(row, columns=None, timestamp=None, include_timestamp=False)：获取一行数据，返回一个dict
row：行
columns: 列，默认为None，即获取所有列，可传入一个list或tuple来指定获取列
timestamp：时间戳。默认为None，即返回最大的那个时间戳的数据。可传入一个时间戳来获取小于此时间戳的最大时间戳的版本数据
include_timestamp：是否返回时间戳数据，默认为False

e.g.:
msg = table.row("rowkey001",columns=None,  include_timestamp=False)

获取多行数据

rows(rows, columns=None, timestamp=None, include_timestamp=False)：获取多行数据，返回一个list
rows：行，可传入一个list或tuple来指定获取
columns: 列，默认为None，即获取所有列，可传入一个list或tuple来指定获取列
timestamp：时间戳。默认为None，即返回最大的那个时间戳的数据。可传入一个时间戳来获取小于此时间戳的最大时间戳的版本数据
include_timestamp：是否返回时间戳数据，默认为False

e.g.:
    msg = table.rows(["rowkey001","rowkey005"],columns=("info:name",))

扫描器

scan(row_start=None, row_stop=None, row_prefix=None, columns=None, filter=None, timestamp=None, include_timestamp=False, batch_size=1000, scan_batching=None, limit=None, sorted_columns=False, reverse=False)：获取一个扫描器，返回一个generator
row_start：起始行，默认None，即第一行，可传入行号指定从哪一行开始
row_stop：结束行，默认None，即最后一行，可传入行号指定到哪一行结束(不获取此行数据)
row_prefix：行号前缀，默认为None，即不指定前缀扫描，可传入前缀来扫描符合此前缀的行
columns：列，默认为None，即获取所有列，可传入一个list或tuple来指定获取列
filter：过滤字符串
timestamp：时间戳。默认为None，即返回最大的那个时间戳的数据。可传入一个时间戳来获取小于此时间戳的最大时间戳的版本数据
include_timestamp：是否返回时间戳数据，默认为False
batch_size：用于检索结果的批量大小
scan_batching：服务端扫描批处理
limit：数量
sorted_columns：是否返回排序的列(根据行名称排序)
reverse：是否执行反向扫描

e.g.:
    # 筛选：rk 包含 rowkey
    query = "RowFilter ( =,  \'substring:{0}\')".format("rowkey")
msg = table.scan("rowkey001", "rowkey005",columns=["info:name"],
filter=query, include_timestamp=False, batch_size=1000, limit=10, sorted_columns=False, reverse=False
                 )
# print(msg)
for k,v in msg:
    print(k,v)

更多见官方文档

posted @ 2021-01-16 21:37 是阿凯啊阅读(527) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

阿凯

hbase

hbase

1.介绍

2.HBASE架构

3.安装

4.HBase表模型

5.Hbase存储数据类型

6.shell命令

7.hfile store flush

8.Hbase JavaApi

9.过滤器

10.读写数据流程

11 row设计的基本思路

12.Phoenix整合hbase

13.Python操作hbase

DDL

DML

公告