一 整合SQL引擎层

  1. NOSQL(Not only SQL 非关系型数据库)的特性之一是不使用SQL作为查询语言,本节简单介绍NOSQL定义,为何NOSQL 上定义SQL引擎,以及现有基于HBASE的SQL引擎的具体实现
  2. NOSQL是不同于传统关系型数据库的数据库系统的统称.两者有很多显著的不同点,其中最重要的是NOSQL不使用SQL作为查询语言.其数据存储可以不需要固定的表格模式,也经常会避免使用SQL的JOIN操作,一般具备水平扩展的特征.NOSQL的实现具有两个特征:使用硬盘或者把随机存储器作为存储媒体

1 把SQL整合到HBASE的原因

现有的SQL解决方案通常都不是水平可伸缩的,因此当数据量变大时会遇到阻力.我们已经知道NOSQL区别于关系型数据库的一点就是NOSQL不使用SQL作为查询语言,至于为何在NOSQL数据存储HBASE上提供SQL接口,有如下三个原因:

  1. 使用诸如SQL这样易于理解的语言,使人们能够更加轻松地使用HBASE
  2. 使用诸如SQL这样更高层次的语言来编写,减少了编码的代码量.
  3. 执行查询时,在数据访问与运行时执行之间加上SQL这样一层抽象可以进行大量优化.

2 基于HBASE的SQL引擎实现

现阶段业内有一些HBASE SQL引擎层的尝试

Hive 整合HBASE

Hive与HBASE的整合功能从Hive0.6版本开始出现,利用两者对外的API接口互相通信,通信主要依赖hive_hbase-handler.jar工具包(Hive Storage Handlers).由于HBASE有一次比较大的版本变动,所以并不是每个版本的Hive都能和现有的HBASE版本进行整合,因此对版本的范围要求比较严格.

Phoenix

Phoenix由Saleforce.com开源,是构建在Apache Hbase之上的一个SQL中间层,可以让开发者在HBASE上执行SQL查询.Phoenix完全使用Java开发,并且提供一个客户端可嵌入的JDBC驱动.对于简单的低延迟查询,其量级为毫秒,对于百万级别的行数来说,其量级为秒.Phoenix并不像HBase那样用于map-reduce job,而是通过标准化的语言来访问HBASE数据.根据项目创建者所述,对于10万到100万行的简单查询来说,Phoenix要胜过Hive.对于使用了HBASE API,协同处理器及自定义过滤器的Impala与OpenTSDB来说,进行相似的查询Phoenix的速度也要更快一些.

Impala

Cloudera发布实时查询开源项目Impala,经多款产品实测表明,比原来基于MapReduce的Hive SQL查询速度提升了3-90倍,Impala是google dremel的模仿,但在SQL功能上青出于蓝.

Impala采用与Hive相同的元数据,SQL语法 ODBC驱动和用户接口,但是对于平台有一定的局限性在CDH上表现良好,在其他平台上兼容性不好.

二 Phoenix的安装与使用

1 概述

Apache Phoenix是构建在HBase之上的关系型数据库层，作为内嵌的客户端JDBC驱动用以对HBase中的数据进行低延迟访问。Apache Phoenix会将用户编写的sql查询编译为一系列的scan操作，最终产生通用的JDBC结果集返回给客户端。数据表的元数据存储在HBase的表中被会标记版本号，所以进行查询的时候会自动选择正确的schema。直接使用HBase的API，结合协处理器（coprocessor）和自定义的过滤器的话，小范围的查询在毫秒级响应，千万数据的话响应速度为秒级。
2.整合SQL引擎层 - 图1

2 Phoenix的特点

  1. 嵌入式的JDBC驱动,实现了大部分的Java.sql接口,包括元数据API
  2. 可以通过多行键/值单元对列进行建模
  3. 完善的查询支持,优化过scan
  4. DDL支持:通过CREATE TABLE DROP TABLE ALETR TABLE实现
  5. 版本化的模式仓库:当写入数据时,快照查询会使用适当的模式
  6. DML支持:用于逐行插入的UPSERT VALUES ,用于相同或不同表之间大量数据传输的UPSERT SELECT,用于删除行的DELETE
  7. 通过客户端的批处理实现的有限事务支持
  8. 紧跟ANSI SQL标准

不同于Hive On HBASE的方式,Phoenix将Query Plan直接使用HBASE API实现,规避MapReduce框架,减少查询的时间延迟.Phoenix中SQL Query Plan的执行,基本上是通过构建一系列HBASE Scan来完成的.

目前支持简单的表创建,修改,数据删除过滤查询等SQL语句,从语法上看,不支持多表操作,由于不支持多表联合类的操作如各种Join等,所以在Where部分也就不能做多表比较.基于HBASE的timestamp和不限制修饰符等等特性,实现了一些有趣的功能,比如动态列,嵌套数据结构,schema演化等.

由于协处理器和过滤器自身能力的限制,如果完全不依赖MapReduce框架,只通过HBASE客户端API想要实现复杂查询操作,如多表联合操作,相对比较困难,或者大量工作需要在客户端代码中实现,性能上可能无法满足需求.

(1)下载

访问Phoenix的官方网站进行下载.下载地址:http://www.apache.org/dyn/closer.lua/phoenix/
2.整合SQL引擎层 - 图2

(2)安装

在Master上面的操作

  1. #sudo tar xvfz phoenix-4.7.0-HBase-1.1-bin.tar.gz 
  2. #sudo chown -R hadoop:hadoop phoenix-4.7.0-HBase-1.1
  3. #sudo chmod -R 775 phoenix-4.7.0-HBase-1.1
  4. #sudo mv phoenix-4.7.0-HBase-1.1 /usr/local/phoenix
  5. #sudo cp /usr/local/phoenix/*.jar /usr/local/hbase/lib/
  6. #sudo cp /usr/local/hbase/conf/hbase-site.xml /usr/local/phoenix/bin/
  7. hadoop@hadoopmaster:/usr/local$ sudo tar cvfz ~/phoenix2016.tar.gz phoenix/
  8. scp /home/hadoop/phoenix2016.tar.gz hadoop@hadoopslave1:/home/hadoop/
  9. scp /home/hadoop/phoenix2016.tar.gz hadoop@hadoopslave2:/home/hadoop/

在Slave上面的操作

  1. hadoop@hadoopslave1:~$ tar xvfz phoenix2016.tar.gz
  2. hadoop@hadoopslave1:~$ sudo mv phoenix /usr/local/phoenix
  3. hadoop@hadoopslave1:~$ sudo chown -R hadoop:hadoop /usr/local/phoenix/
  4. hadoop@hadoopslave1:~$ sudo chmod -R 775 /usr/local/phoenix/
  5. hadoop@hadoopslave1:/usr/local/phoenix$ cp *.jar /usr/local/hbase/lib/

完成以上步骤,基本上Phoenix就安装成功了.

(3)基本使用

验证操作

  1. hadoop@Master:/usr/local/phoenix/bin$ ./sqlline.py localhost
  2. 执行SQL语句
  3. CREATE TABLE IF NOT EXISTS us_population2 (
  4.       state CHAR(2) NOT NULL,
  5.       city VARCHAR NOT NULL,
  6.       population BIGINT
  7.       CONSTRAINT my_pk2 PRIMARY KEY (state, city));
  9. 插入操作
  11. upsert into us_population2(state, city, population) values('NY', 'New York', 8143197);
  12. upsert into us_population2(state, city, population) values('CA', 'Chicago', 2842518);
  13. upsert into us_population2(state, city, population) values('TX', 'Houston', 2016582);
  14. upsert into us_population2(state, city, population) values('TX', 'San Antonio', 1256509);
  15. upsert into us_population2(state, city, population) values('CA', 'San Jose', 912332);
  17. 执行操作
  19. SELECT state as "State",count(city) as "City Count",sum(population) as "Population Sum"
  20. FROM us_population2
  21. GROUP BY state
  22. ORDER BY sum(population) DESC;
  24. 0: jdbc:phoenix:localhost> SELECT state as "State",count(city) as "City Count",sum(population) as "Population Sum"
  25. . . . . . . . . . . . . .> FROM us_population2
  26. . . . . . . . . . . . . .> GROUP BY state
  27. . . . . . . . . . . . . .> ORDER BY sum(population) DESC;
  28. +--------+-------------+-----------------+
  29. | State  | City Count  | Population Sum  |
  30. +--------+-------------+-----------------+
  31. | NY     | 1           | 8143197         |
  32. | CA     | 2           | 3754850         |
  33. | TX     | 2           | 3273091         |
  34. +--------+-------------+-----------------+
  35. 3 rows selected (0.087 seconds)
  36. 0: jdbc:phoenix:localhost>

语法索引

http://phoenix.apache.org/language/index.html

使用JDBC访问Phoenix

  1. package com.chu;
  3. /**
  4.  * Created by chuguangming on 16/9/23.
  5.  */
  7. import java.sql.*;
  10. class BaseDB {
  12.     /**
  13.      * name：getConnection
  14.      * time：2015年5月6日 下午2:07:06
  15.      * description： get JDBC connection
  16.      *
  17.      * @return connection
  18.      */
  19.     public static Connection getConnection() {
  20.         try {
  21.             // load driver
  22.             Class.forName("org.apache.phoenix.jdbc.PhoenixDriver");
  24.             // get connection
  25.             // jdbc 的 url 类似为 jdbc:phoenix [ :<zookeeper quorum> [ :<port number> ] [ :<root node> ] ]，
  26.             // 需要引用三个参数：hbase.zookeeper.quorum、hbase.zookeeper.property.clientPort、and zookeeper.znode.parent，
  27.             // 这些参数可以缺省不填而在 hbase-site.xml 中定义。
  28.             return DriverManager.getConnection("jdbc:phoenix:hadoopmaster,hadoopslave1,hadoopslave2");
  29.         } catch (Exception e) {
  30.             e.printStackTrace();
  31.             return null;
  32.         }
  33.     }
  36. }
  39. public class HBaseSQLDriverTest {
  40.     public static void main(String[] args) throws SQLException {
  41.         //Simpletest();
  42.         //create();
  43.         //upsert();
  44.         //query();
  45.         //delete();
  46.     }
  48.     /**
  49.      * name：delete
  50.      * time：2015年5月4日 下午4:03:11
  51.      * description：delete data
  52.      */
  53.     public static void delete() {
  55.         Connection conn = null;
  56.         try {
  57.             // get connection
  58.             conn = BaseDB.getConnection();
  60.             // check connection
  61.             if (conn == null) {
  62.                 System.out.println("conn is null...");
  63.                 return;
  64.             }
  66.             // create sql
  67.             String sql = "delete from user88888 where id='001'";
  69.             PreparedStatement ps = conn.prepareStatement(sql);
  71.             // execute upsert
  72.             String msg = ps.executeUpdate() > 0 ? "delete success..."
  73.                     : "delete fail...";
  75.             // you must commit
  76.             conn.commit();
  77.             System.out.println(msg);
  79.         } catch (SQLException e) {
  80.             e.printStackTrace();
  81.         } finally {
  82.             if (conn != null) {
  83.                 try {
  84.                     conn.close();
  85.                 } catch (SQLException e) {
  86.                     e.printStackTrace();
  87.                 }
  88.             }
  89.         }
  91.     }
  93.     public static void query() {
  95.         Connection conn = null;
  96.         try {
  97.             // get connection
  98.             conn = BaseDB.getConnection();
  100.             // check connection
  101.             if (conn == null) {
  102.                 System.out.println("conn is null...");
  103.                 return;
  104.             }
  106.             // create sql
  107.             String sql = "select * from user88888";
  109.             PreparedStatement ps = conn.prepareStatement(sql);
  111.             ResultSet rs = ps.executeQuery();
  113.             System.out.println("id" + "\t" + "account" + "\t" + "passwd");
  114.             System.out.println("======================");
  116.             if (rs != null) {
  117.                 while (rs.next()) {
  118.                     System.out.print(rs.getString("id") + "\t");
  119.                     System.out.print(rs.getString("account") + "\t");
  120.                     System.out.println(rs.getString("passwd"));
  121.                 }
  122.             }
  124.         } catch (SQLException e) {
  125.             e.printStackTrace();
  126.         } finally {
  127.             if (conn != null) {
  128.                 try {
  129.                     conn.close();
  130.                 } catch (SQLException e) {
  131.                     e.printStackTrace();
  132.                 }
  133.             }
  134.         }
  136.     }
  138.     /**
  139.      * name：insert
  140.      * time：2015年5月4日 下午2:59:11
  141.      * description：
  142.      */
  143.     public static void upsert() {
  145.         Connection conn = null;
  146.         try {
  147.             // get connection
  148.             conn = BaseDB.getConnection();
  150.             // check connection
  151.             if (conn == null) {
  152.                 System.out.println("conn is null...");
  153.                 return;
  154.             }
  156.             // create sql
  157.             String sql = "upsert into user88888(id, INFO.account, INFO.passwd) values('001', 'admin', 'admin')";
  159.             PreparedStatement ps = conn.prepareStatement(sql);
  161.             // execute upsert
  162.             String msg = ps.executeUpdate() > 0 ? "insert success..."
  163.                     : "insert fail...";
  165.             // you must commit
  166.             conn.commit();
  167.             System.out.println(msg);
  169.         } catch (SQLException e) {
  170.             e.printStackTrace();
  171.         } finally {
  172.             if (conn != null) {
  173.                 try {
  174.                     conn.close();
  175.                 } catch (SQLException e) {
  176.                     e.printStackTrace();
  177.                 }
  178.             }
  179.         }
  180.     }
  182.     public static void create() {
  183.         Connection conn = null;
  184.         try {
  185.             // get connection
  186.             conn = BaseDB.getConnection();
  188.             // check connection
  189.             if (conn == null) {
  190.                 System.out.println("conn is null...");
  191.                 return;
  192.             }
  194.             // check if the table exist
  195.             ResultSet rs = conn.getMetaData().getTables(null, null, "USER",
  196.                     null);
  197.             if (rs.next()) {
  198.                 System.out.println("table user is exist...");
  199.                 return;
  200.             }
  201.             // create sql
  202.             String sql = "CREATE TABLE user88888 (id varchar PRIMARY KEY,INFO.account varchar ,INFO.passwd varchar)";
  204.             PreparedStatement ps = conn.prepareStatement(sql);
  206.             // execute
  207.             ps.execute();
  208.             System.out.println("create success...");
  210.         } catch (SQLException e) {
  211.             e.printStackTrace();
  212.         } finally {
  213.             if (conn != null) {
  214.                 try {
  215.                     conn.close();
  216.                 } catch (SQLException e) {
  217.                     e.printStackTrace();
  218.                 }
  219.             }
  220.         }
  222.     }
  224.     private static void Simpletest() throws SQLException {
  225.         Statement stmt = null;
  226.         ResultSet rs = null;
  227.         String viewName = "\"US_POPULATION2\""; // 这是对HBase表"food:products"创建的Phoenix view
  229.         System.err.println("\n[viewName = " + viewName + "]\n");
  231.         /* ecs1.njzd.com:2181是zookeeper的某一个节点的ip:port
  232.            即使集群中的ZooKeeper存在多个节点，这里也只需要写出一个节点的ip:port就可以了*/
  233.         // 如果是Scala，还需要这一句
  234.         //Class.forName("org.apache.phoenix.jdbc.PhoenixDriver");
  235.         Connection conn = DriverManager.getConnection("jdbc:phoenix:hadoopmaster,hadoopslave1,hadoopslave2");
  237.         /* 在Phoenix中，如果table name/view name、column name等字符串不加上双引号就会被认为是大写。所以，这里的brand_name要加上双引号  */
  238.         PreparedStatement pstmt = conn.prepareStatement("select * from " + viewName);
  239.         rs = pstmt.executeQuery();
  241.         while (rs.next()) {
  243.             System.err.println(rs.getString("STATE"));
  245.             System.err.println("\n=========================================================");
  246.         }
  247.         /* 关闭资源*/
  248.         rs.close();
  249.         pstmt.close();
  250.     }
  251. }

pom.xml

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xmlns="http://maven.apache.org/POM/4.0.0"
  3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  5.     <modelVersion>4.0.0</modelVersion>
  7.     <groupId>com.chu</groupId>
  8.     <artifactId>HBaseDemo</artifactId>
  9.     <version>1.0-SNAPSHOT</version>
  10.     <dependencies>
  11.         <!-- https://mvnrepository.com/artifact/org.apache.hive/hive-jdbc -->
  12.         <dependency>
  13.             <groupId>org.apache.hive</groupId>
  14.             <artifactId>hive-jdbc</artifactId>
  15.             <version>2.1.0</version>
  16.         </dependency>
  17.         <!-- https://mvnrepository.com/artifact/org.hibernate.javax.persistence/hibernate-jpa-2.0-api -->
  18.         <dependency>
  19.             <groupId>org.hibernate.javax.persistence</groupId>
  20.             <artifactId>hibernate-jpa-2.0-api</artifactId>
  21.             <version>1.0.1.Final</version>
  22.         </dependency>
  23.         <dependency>
  24.             <groupId>org.apache.hive</groupId>
  25.             <artifactId>hive-exec</artifactId>
  26.             <version>2.1.0</version>
  27.         </dependency>
  28.         <!-- https://mvnrepository.com/artifact/org.apache.hbase/hbase-client -->
  29.         <dependency>
  30.             <groupId>org.apache.hbase</groupId>
  31.             <artifactId>hbase-client</artifactId>
  32.             <version>1.1.5</version>
  33.         </dependency>
  34.         <!-- https://mvnrepository.com/artifact/org.apache.hbase/hbase -->
  35.         <dependency>
  36.             <groupId>org.apache.hbase</groupId>
  37.             <artifactId>hbase</artifactId>
  38.             <version>1.1.5</version>
  39.             <type>pom</type>
  40.         </dependency>
  41.         <!-- https://mvnrepository.com/artifact/org.apache.hbase/hbase-common -->
  42.         <dependency>
  43.             <groupId>org.apache.hbase</groupId>
  44.             <artifactId>hbase-common</artifactId>
  45.             <version>1.1.5</version>
  46.         </dependency>
  47.         <!-- https://mvnrepository.com/artifact/org.apache.hbase/hbase-server -->
  48.         <dependency>
  49.             <groupId>org.apache.hbase</groupId>
  50.             <artifactId>hbase-server</artifactId>
  51.             <version>1.1.5</version>
  52.         </dependency>
  53.         <!-- https://mvnrepository.com/artifact/org.apache.hbase/hbase-protocol -->
  54.         <dependency>
  55.             <groupId>org.apache.hbase</groupId>
  56.             <artifactId>hbase-protocol</artifactId>
  57.             <version>1.1.5</version>
  58.         </dependency>
  59.         <!-- https://mvnrepository.com/artifact/org.apache.phoenix/phoenix-core -->
  60.         <dependency>
  61.             <groupId>org.apache.phoenix</groupId>
  62.             <artifactId>phoenix-core</artifactId>
  63.             <version>4.7.0-HBase-1.1</version>
  64.         </dependency>
  66.     </dependencies>
  67.     <repositories>
  68.         <repository>
  69.             <id>jboss</id>
  70.             <url>http://maven.aliyun.com/nexus/content/groups/public/</url>
  71.         </repository>
  72.     </repositories>
  73. </project>