精华内容
下载资源
问答
  • Phoenix(凤凰)安装部署及介绍

    万次阅读 2020-01-07 08:46:37
    Phoenix介绍 phoenix,中文译为“凤凰”,很美的名字。Phoenix是由saleforce.com开源的一个项目,后又捐给了Apache基金会。它相当于一个Java中间件,提供jdbc连接,操作hbase数据表。Phoenix是一个HBase的开源SQL...

    Phoenix介绍

    phoenix,中文译为“凤凰”,很美的名字。Phoenix是由saleforce.com开源的一个项目,后又捐给了Apache基金会。它相当于一个Java中间件,提供jdbc连接,操作hbase数据表。Phoenix是一个HBase的开源SQL引擎。你可以使用标准的JDBC API代替HBase客户端API来创建表,插入数据,查询HBase数据。
    支持SQL的还有Hive和Impala。但是Hive和Impala还可以查询文本文件,Phoenix只能查Hbase。
    Phoenix是构建在HBase之上的SQL引擎。其查询效率相同或高于Hbase原生查询性能,同时提高了开发效率,降低学习成本。除此之外,Phoenix还做了一些增强功能来更多地优化性能,例如二级索引、跳过扫描过滤器优化IN,LIKE,OR查询、优化主键。

    Phoenix的安装部署

    1 、提前安装好ZK集群、hadoop集群、Hbase集群
    2、从对应的地址下载:http://mirrors.cnnic.cn/apache/phoenix/
    这里我们使用的是:apache-phoenix-4.14.0-		cdh5.14.2-bin.tar.gz
    3、上传、解压 
    将对应的安装包上传到对应的Hbase集群其中一个服务器的/export/softwares目录下
    解压:tar zxvf apache-phoenix-4.14.0-cdh5.14.2-	bin.tar.gz -C /export/servers/
    重命名:mv apache-phoenix-4.14.0-cdh5.14.2-bin/ 	phoenix
    4、配置
    (1) 将phoenix目录下的phoenix-4.14.0-cdh5.14.2-server.jar拷贝到各个 hbase的lib目录下。
    在hbase 配置值文件hbase-site.xml文件中添加配置
    <property>
    <name>hbase.regionserver.wal.codec</name>
    <value>org.apache.hadoop.hbase.regionserver.wal.IndexedWALEditCodec</value>
    </property>
    <property>
    <name>zookeeper.znode.parent</name>
    <value>/hbase</value>
    </property>
    同步至所有hbase节点后,将hbase-site.xml拷贝到phoenix/bin目录下
    (2)重启hbase集群,使Phoenix的jar包生效。
    5、验证是否成功
    在phoenix/bin下输入命令:
    端口可以省略
    [root@node01 bin]# ./sqlline.py node01:2181
    
    
    输入!tables 查看都有哪些表。SYSTEM为Phoenix系统表,系统表中维护了用户表的元数据信息。
    
    退出Phoenix。输入!quit  或!q
    

    Phoenix使用

    Phoenix可以有4种方式调用:

    批处理方式
    命令行方式
    GUI方式
    JDBC调用方式

    (1)批处理方式

    A: 创建user_phoenix.sql文件
    内容如下
    CREATE TABLE IF NOT EXISTS user_phoenix ( 
    state CHAR(2) NOT NULL,  
    city VARCHAR NOT NULL, 
    population BIGINT  
    CONSTRAINT my_pk PRIMARY KEY (state, city)
    );
    B: 创建user_phoenix.csv数据文件
    NY,New York,8143197
    CA,Los Angeles,3844829
    IL,Chicago,2842518
    TX,Houston,2016582
    PA,Philadelphia,1463281
    AZ,Phoenix,1461575
    TX,San Antonio,1256509
    CA,San Diego,1255540
    TX,Dallas,1213825
    CA,San Jose,912332
    C: 创建user_phoenix_query.sql文件
    内容为:
    SELECT state as "State",count(city) as "City 	Count",sum(population) as "Population Sum" FROM user_phoenix GROUP BY state ORDER BY sum(population) DESC; 
    D: 执行
    python /export/servers/phoenix-4.14.0-cdh5.14.2/bin/psql.py node01:2181 user_phoenix.sql user_phoenix.csv  user_phoenix_query.sql
    这条命令同时做了三件事:创建表、插入数据、查询结果
    
    用Hbase shell 看下会发现多出来一个 USER_PHOENIX 表,用scan 命令查看一下这个表的数据
    
    结论:
    之前定义的Primary key 为state,city, 于是Phoenix就把输入的state,city的值拼起来成为rowkey
    其他的字段还是按照列名去保存,默认的列族为0
    还有一个0:_0这个列是没有值的,这个是Phoenix处于性	能方面考虑增加的一个列,不用管这个列
    

    (2) 命令行方式

    A: 执行命令
    ./sqlline.py  node01:2181 可以进入命令行模式
    B: 相关命令 
    开头需要一个感叹号
    使用help可以打印出所有命令
    !all          	对所有当前连接执行指定的SQL
    !autocommit   	打开或关闭自动提交模式
    !batch        	启动或执行一批语句
    !brief        	关闭详细模式
    !call         	执行可调用语句
    !close        	关闭与数据库的当前连接
    !closeall     	关闭所有当前打开的连接
    !columns      	列出指定表的所有列
    !commit       	提交当前事务(如果自动提交已关闭)
    !connect      	打开与数据库的新连接。
    !dbinfo       	提供有关数据库的元数据信息
    !describe     	描述一个表
    !dropall      	删除当前数据库中的所有表
    !exportedkeys 	列出指定表的所有导出键
    !go           	选择当前连接
    !help         	打印命令使用情况摘要
    !history      	显示命令历史记录
    !importedkeys 	列出指定表的所有导入键
    !indexes      	列出指定表的所有索引
    !isolation    	为此连接设置事务隔离
    !list         	列出当前连接
    !manual       	显示sqlline手册
    !metadata     	获取元数据信息
    !nativesql    	显示指定语句的本机SQL
    !outputformat 	设置显示结果的输出格式(表格、垂直、csv、tsv、xmlattrs、xmleelements)
    !primarykeys  	列出指定表的所有主键
    !procedures   	列出所有程序
    !properties   	连接到属性文件中指定的数据库
    !quit         	退出程序
    !reconnect    	重新连接到数据库
    !record       	将所有输出记录到指定文件
    !rehash       	获取用于完成命令的表和列名称
    !rollback     	回滚当前事务(如果关闭自动提交)
    !run          	从指定的文件运行脚本
    !save         	保存当前变量和别名
    !scan         	扫描已安装的JDBC驱动程序
    !script       	开始将脚本保存到文件
    !set          	设置sqlline变量
    
    C: 建立employee的映射表---数据准备
    数据准备然后我们来建立一个映射表,映射我之前建立	过的一个hbase表 employee.有2个列族 company、family
    create 'employee1','company','family'
    put 'employee1','row1','company:name','ted'
    put 'employee1','row1','company:position','worker'
    put 'employee1','row1','family:tel','136009123xx'
    put 'employee1','row2','company:name','michael'
    put 'employee1','row2','company:position','manager'
    put 'employee1','row2','family:tel','189422xxxx'
    scan 'employee1'
    在建立映射表之前要说明的是,Phoenix是大小写敏感	的,并且所有命令都是大写,如果你建的表名没有用双引号括起来,那么无论你输入的是大写还是小写,建立出来的表名都是大写的,如果你需要建立出同时包含大写和小写的表名和字段名,请把表名或者字段名用双引号括起来。
    你可以建立读写的表或者只读的表,他们的区别如下
    读写表:如果你定义的列簇不存在,会被自动建立出	来,并且赋以空值
    只读表:你定义的列簇必须事先存在
    
    D: 建立映射表
    0: jdbc:phoenix:node01>
    CREATE TABLE IF NOT EXISTS "employee1" (
    "no" VARCHAR(10) NOT NULL PRIMARY KEY, 
    "company"."name" VARCHAR(30),
    "company"."position" VARCHAR(20), 
    "family"."tel" VARCHAR(20), 
    "family"."age" INTEGER
    );
    这个语句有几个注意点
    IF NOT EXISTS可以保证如果已经有建立过这个表,配置不会被覆盖
    作为rowkey的字段用 PRIMARY KEY标定
    列簇用 columnFamily.columnName 来表示
    family.age 是新增的字段,之前建立测试数据的时候没	有建立这个字段的原因是在hbase shell下无法直接写入数字型,使用UPSERT 命令插入数据的时候就可以看到真正	的数字型在hbase 下是如何显示的
    建立好后,查询一下数据
    
    E: 查询映射表数据
    0: jdbc:phoenix:node01> SELECT * FROM "employee";
    +-------+----------+-----------+--------------+-------+
    |  no   |   name   | position  |     tel      |  age  |
    +-------+----------+-----------+--------------+-------+
    | row1  | ted      | worker    | 136009123xx  | null  |
    | row2  | michael  | manager   | 189422xxxx  | null  |
    +-------+----------+-----------+--------------+-------+
    
    F: 插入数据、更改数据
    

    插入或者更改数据在phoenix中使用upsert关键字,
    如果表中不存在该数据则插入,否则更新
    插入:
    0:jdbc:phoenix:node01>
    upsert into “employee” values(‘row3’,‘billy’,‘worker’,‘1697468xxxx’,33);

    修改数据:
    0: jdbc:phoenix:node01:2181>
    upsert into “employee” (“no”,“tel”) VALUES (‘row2’,‘1358888xxxx’);

    查询:
    0: jdbc:phoenix:node01:2181> select * from “employee”;
    ±------±---------±----------±-------------±------+
    | no | name | position | tel | age |
    ±------±---------±----------±-------------±------+
    | row1 | ted | worker | 136009123xx | null |
    | row2 | michael | manager | 13588888888 | null |
    | row3 | billy | worker | 1697468xxxx | 33 |
    ±------±---------±----------±-------------±------+
    3 rows selected (0.06 seconds)

    G: 查询Hbase数据
    hbase(main):056:0> scan 'employee'
    ROW                   COLUMN+CELL                                                                 
     row1            column=company:_0, 	timestamp=1484730892661, value=                          
     row1            column=company:name, 	timestamp=1484730892527, value=ted                     
     row1            column=company:position, timestamp=1484730892565, value=worker              
     row1            column=family:tel, timestamp=1484730892661, value=13600912345               
     row2            column=company:_0, timestamp=1484730892762, value=                          
     row2            column=company:name, timestamp=1484730892702, value=michael                 
     row2            column=company:position, timestamp=1484730892730, value=manager             
     row2            column=family:tel, timestamp=1484730892762, value=13588888888  
     row3            column=company:_0, timestamp=1484809036587, value=x                         
     row3            column=company:name, timestamp=1484809036587, value=billy                   
     row3            column=company:position, timestamp=1484809036587, value=worker              
     row3            column=family:age, timestamp=1484809036587, value=\x80\x00\x00!             
     row3            column=family:tel, timestamp=1484809036587, value=16974681345     
    company:_0这个列是没有值的,这个是Phoenix处于性能方面考虑增加的一个列,不用管这个列。
    

    (3): GUI方式

    A: squirrel下载
    从网址http://www.squirrelsql.org/下载相应版本的squirrel的安装jar包,比如下载squirrel-sql-3.7-standard.jar window版本。
    
    B:  squirrel安装
    Window下:通过cmd进入window控制台,
    输入 java -jar squirrel-sql-3.7-standard.jar 
    显示安装界面。
    
    C: squirrel配置连接Phoenix
    配置squirrel
    解压的phoenix-4.7.0-HBase-1.1-bin.tar.gz包的主目录下	将如下几个jar包拷贝到squirrel安装目录的lib下
    
     在安装目录下双击squirrel-sql.bat、点击左侧的Drivers,添加图标
    
    配置说明:
    在出现的窗口中填写如下项
     Name:就是个名字任意取就可以,这里使用phoenix
     Example URL :jdbc:phoenix:node01:2181(这里是你的phonenix的jdbc地址,注意端口也可以不写,多个用逗号隔开)
     Class Name:org.apache.phoenix.jdbc.PhoenixDriver
    
    D: 连接Phoenix
    点击Aiiasses,点击右边的添加图标
    配置说明:
    这里还是名字随意写(这里使用phoenix),driver要选择刚才配置的可用的driver,我们刚才配置的是phoenix
    url这里就是连接phonex的url选择了phoenix的driver以后自动出现也可以改,user name就是phoenix连接的主机的用户名,密码就是该机器的密码,点击自动登录
    然后点击test,显示连接成功即可(在这里最好不要直接点OK,先点Test,连接成功了再OK)
    点击OK按钮
    查看对应的表
    通过sql语句查询数据
    

    (4) JDBC调用方式

    打开Eclipse建立一个简单的Maven项目 phoenix
    <?xml version="1.0" encoding="UTF-8"?>
    

    <project xmlns=“http://maven.apache.org/POM/4.0.0”
    xmlns:xsi=“http://www.w3.org/2001/XMLSchema-instance”
    xsi:schemaLocation=“http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd”

    <packaging>jar</packaging>
    <name>phoenix</name>
    <url>http://maven.apache.org</url>
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>
    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>3.8.1</version>
        </dependency>
        <dependency>
            <groupId>org.apache.phoenix</groupId>
            <artifactId>phoenix-core</artifactId>
            <version> 4.14.1-HBase-1.2</version>
        </dependency>
    </dependencies>
    

    建立一个类 PhoenixManager

    package cn.itcast.phoenix;
    
    import java.sql.Connection;
    import java.sql.DriverManager;
    import java.sql.ResultSet;
    import java.sql.SQLException;
    import java.sql.Statement;
    
    
    public class PhoenixManager {
    	public static void main(String[] args) throws SQLException {
    		Connection conn=null;
    		Statement state=null;
    		ResultSet rs=null;
    		try {
    			Class.forName("org.apache.phoenix.jdbc.PhoenixDriver");
    		    conn = DriverManager.getConnection("jdbc:phoenix:node01:2181");
    		    state=conn.createStatement();
    		    rs=  state.executeQuery("select * from \"employee\"");
    		    
    		    while(rs.next()){
    		    	System.out.println("no:"+rs.getString("no"));
    		    	System.out.println("name:"+rs.getString("name"));
    		    	System.out.println("position:"+rs.getString("position"));
    		    	System.out.println("age:"+rs.getInt("age"));
      System.out.println("-------------------------");
    		    }
    		    
    		} catch (Exception e) {
    			e.printStackTrace();
    			
    		}finally{
    			
    			if(rs!=null)rs.close();
    			
    			if(state!=null) state.close();
    			
    			if(conn!=null) conn.close();
    			
    		}
    		
    	}
    }
    
    运行结果展现:
    no:row1
    name:ted
    position:worker
    age:0
    -------------------------
    no:row2
    name:michael
    position:manager
    age:0
    -------------------------
    no:row3
    name:billy
    position:worker
    age:33
    -------------------------
    

    Phoenix常用命令

    创建phoenix表
    create table if not exists testtable(
    A  bigint not null,
    B  double, 
    C  varchar(200),
    D  varchar(200) 
    CONSTRAINT testtable PRIMARY KEY(A));
    
    查看表结构
    !desc  testtable;
    
    删除表
    drop  table  testable;
    
    向表添加数据
    python /export/servers/phoenix-4.14.0-cdh5.14.2/bin/psql.py -t testable  node01 /opt/xxx.csv
    
    数据查询
    Select  *  from  testable  where  A> 100;
    

    Phoenix索引

    在海量数据背景下,查询数据快速返回是典型的应用场景。在phoenix数据表基础之上创建索引,能够大幅提高数据的查询效率。Phoenix支持的索引有三个类型,分别是覆盖索引、全局索引、本地索引。
    
    A: 覆盖索引Covered Index
    覆盖索引要求查询语句中的条件字段、查询字段都必须	创建过索引,否则就会触发“全局扫描”(full table scan)
    创建语法:create  index  coverindex  user_index  on  user (name)  include  (age);
    因此它的特点是:只需要通过索引就能返回所要查询的数据 。
    
    B: 全局索引Global indexes
    global是默认的索引格式。
    
    全局索引适用于多读少写的场景,在写操作上会给性能带来极大的开销,因为所有的更新和写操作(DELETE,UPSERT VALUES和UPSERT SELECT)都会引起索引的更新,在读数据时,Phoenix将通过索引表来达到快速查询的目的。	如;
    create  index  userid_index  on  user  (userid);
    它有一个缺陷,如果查询语句中的条件字段或查询字段不是索引字段,就会触发全表扫描。例如:select userid,name  from  user  where  userid='8960321’
    
    解决办法有两个:
    一是和覆盖索引一样,创建索引时把查询的相关字放入段include来。
    create  index  userid_index  on  user  (userid)  include  (name );
    
    二是强制使用索引:
    select /*+ index(user,userid_index) */ name  FROM  user  userid='8960321’;
    
    制使用索引的查询语句会导致二次检索数据表,第一次检索是去索引表中查找符合userid='8960321’的数据,此时候发现 name 字段并不在索引字段中,会去user 表中第二次扫描name。因此只有当用户明确知道name符合检索条件的数据较少的时候才适合使用,否则会造成全表扫描,对性能影响较大。
    
    C: 本地索引Local Indexing
    与Global Indexing不同,本地索引适用于写多读少的场景,当使用Local Indexing的时候即使查询的所有字段都不在索引字段中时也会用到索引进行查询,Phoneix在查询时会自动选择是否使用本地索引(这是由Local Indexing自动完成的)。
    
    create  local  index  user_Index  on  user  (userid,name);
    
    D: 索引常用操作
    查看表索引
     !index "harve_user";
    
    删除索引
    drop index user_Index  on  user;
    
    E: 索引有序性
    创建的索引字段的顺序,与查询语句条件字段的顺序,两者之间的对应关系对索引是否生效有较大影响。
    查询语句条件字段的顺序尽量与索引的顺序相同。索引的首字段在查询条件中尽量第一个出现。
    
    测试
    创建测试表
    create table if not exists testdata(
    A bigint not null,
    B bigint,
    C bigint,
    D bigint,
    E bigint,
    F bigint,
    G bigint,
    H bigint,
    I bigint
    CONSTRAINT testdata PRIMARY KEY(A));
    
    加载一千万数据
    python /export/servers/phoenix-4.14.0-cdh5.14.2/bin/psql.py -t TESTDATA  node01 TestDatas.csv
    
    创建索引
    CREATE INDEX testdataindex  ON testdata 	(B,C,D,E,F) 
    
    查询效率对比
    

    在这里插入图片描述

    展开全文
  • win10下虚拟机VMware安装PhoenixOS(凤凰OS)

    万次阅读 多人点赞 2018-05-01 18:30:07
    虚拟机VMware安装PhoenixOS(凤凰OS) 虚拟机VMware安装PhoenixOS(凤凰OS) 0.什么是PhoenixOS 1.下载PhoenixOS镜像 2.下载VMware 3.开始安装系统 第一步新建虚拟机 第二步安装PhoenixOS 第三步为PhoenixOS引导添加...

    虚拟机VMware安装PhoenixOS(凤凰OS)


    0.什么是PhoenixOS

    1. 曾经开发了著名浏览器世界之窗(The World)的凤凰工作室在变身为北京超卓科技有限公司之后,吸引了奇虎360、阿里巴巴的一些研发成员,打造出了一套“凤凰系统”(Phoenix OS),简单说就是x86桌面版的安卓。1.凤凰系统—百度百科

    PhoenixOS就是x86版安卓,能在PC等x86或x64构架处理器的计算机上运行。

    安装前须知:
    安装需要的环境: 在电脑中打开VT或者VT-d(硬件虚拟化技术)。(由于各个电脑打开方式虽说大相径庭但是仍有区别,所以最好自己百度“电脑型号+打开vt(或者硬件虚拟化技术)”
    安装需要的工具: PhoenixOS镜像、Vmware

    1.下载PhoenixOS镜像

    首先在官网(http://www.phoenixos.com/)中下载最新的PhoenixOS镜像文件(在我写这篇博客时,PhoenixOS已经更新到v2.6.3,基于Android7.1)
    1.打开官网]

    2.点击“凤凰系统”
    这里写图片描述
    3.点击“PC版”
    这里写图片描述
    4.在打开的界面往下移,移到其他安装方式,选择PhoenixOSInstaller-v2.6.3 (基于 Android7.1)ISO镜像,点击官方下载。等待下载完成,这样你的PhoenixOS镜像就下载完成了。
    这里写图片描述

    2.下载VMware

    这项自行百度,百度上一大堆破解资源,VM12及以上就行了

    3.开始安装系统

    第一步新建虚拟机

    1.点击创建新的虚拟机
    这里写图片描述
    2.弹出欢迎使用新建虚拟机向导,选择“典型(推荐)”,下一步
    这里写图片描述
    3.选择“安装程序光盘映像文件”,选择你刚刚下好的PhoenixOS ISO镜像文件,它会自动显示已检测到FreeBSD,点击下一步
    这里写图片描述
    4.命名虚拟机
    这里写图片描述
    5.把虚拟机名称自己命名,推荐就PhoenixOS,然后选择虚拟机放在磁盘中的位置。然后下一步
    这里写图片描述
    6.分配虚拟机大小。随便你分配,只要大小恰当(系统大小+预计会安装软件的大小+3G以上的缓存及其他文件存放空间),反正我就直接整的32G(傲娇脸),然后下一步
    这里写图片描述
    7.弹出“已准备好创建虚拟机”,选择自定义硬件
    这里写图片描述
    8.在弹出的窗口中选择内存,根据自己电脑的内存来修改给虚拟机的内存
    这里写图片描述
    9.再选择“处理器”项根据自己电脑配置选择处理器核心,看自己的处理器是几核几线程的再来修改
    这里写图片描述
    10.之后就选择关闭,完成。这样虚拟机就创建好了,虚拟机会自动重启,但是这个时候相当于你创建了一个虚拟的电脑,也就是说你现在组装了一台电脑,但是电脑硬盘里面是空的,没系统。下面,咋们开始安装PhoenixOS。

    第二步安装PhoenixOS

    1.完成创建虚拟机后,虚拟机会自动重启,并打开你ISO文件里面的文件/系统
    这里写图片描述
    2.选择第二项“Installation - Install Phoenix OS to harddisk”(安装PhoenixOS到硬盘中)
    这里写图片描述
    3.弹出一个窗口
    这里写图片描述
    4.选择第二项Create/Modify partitons
    这里写图片描述
    5.显示是否要使用GPT,但是我们准备用legacy引导系统,所以不需要GPT,选择No,回车
    这里写图片描述
    6.接着进入磁盘管理器,可以看到现在之佛与一个大小为21467.99MB的磁盘(因为我之前给虚拟机分配空间时选的是默认的20G),按方向右键,选择New,回车
    这里写图片描述
    7.选择Primary主要的磁盘,回车
    这里写图片描述
    8.之后选择大小,默认选择最大大小,所以我们不需要修改,直接回车下一步
    这里写图片描述
    9.在选择Bootable引导,回车
    这里写图片描述
    10.方向右键,移到write保存
    这里写图片描述
    11.输入yes,回车
    这里写图片描述
    12.再按方向右键移到Quit回车,退出磁盘管理系统
    这里写图片描述
    13.这样咋们磁盘创建就创建成功了,然后选中刚才创建的磁盘,回车
    这里写图片描述
    14.选择磁盘是否格式化,并选择格式化的磁盘类型,选择ext4,回车
    这里写图片描述
    15.弹出说确定时候要格式化,选择yes,回车
    这里写图片描述
    16.弹出说是否要安装EFI GRUB2引导系统,因为我们用的是legacy传统化引导方式,所以选择skip跳过
    这里写图片描述
    17.接着又弹出说是否安装grub引导,选择yes
    这里写图片描述
    18.等待安装完成,完成后弹出说安装成功,选择Run Phoenix OS,选择OK ,回车,重启
    这里写图片描述
    19.目前,我们的PhoenixOS就成功安装在虚拟机内了,接着会自动重启,会卡在这个界面下。然后手动从键盘输入reboot,接着虚拟机重启
    这里写图片描述
    这里写图片描述
    接下来我们需要打开虚拟机,对虚拟机中的PhoenixOS引导进行配置

    第三步为PhoenixOS引导添加nomodeset参数

    1. 如果你不加nomodeset,系统将无法启动,但是为什么,抱歉,我不知道,如果有安慰大神知道,欢迎留言分享下!!!感谢。
    2. 虚拟机每次重新启动或者关机后启动都得重新再来加一次nomodeset,所以当你不用虚拟机时最好选择挂起虚拟机而不是选择关闭虚拟机

    1.完成上面后,虚拟机会重启,进入引导界面
    这里写图片描述
    2.接着按e,进入如图所示界面
    这里写图片描述
    3.接着再按e,进入如图所示界面
    这里写图片描述
    4.然后输入“ nomodeset”,注意nomodeset与PhoenixOS中间有个空格,然后回车
    这里写图片描述
    5.之后回到上一级界面,按b启动系统。
    这里写图片描述
    6.闪过系统自检,等待系统启动
    这里写图片描述

    第四步首次进入系统

    1.完成上面所述步骤后,会出现如下界面
    这里写图片描述
    2.等待会,时长根据你电脑配置以及给虚拟机配置的硬件配置而定,然后出现语言选择界面,默认中文,选择下一步
    这里写图片描述
    3.弹出用户许可,点击接受
    这里写图片描述
    4.选择网络,因为之前配置是虚拟机于物理机共用网络,所以他会显示你已经连接有线网络
    这里写图片描述
    5.之后弹出创建账号,输入你想要的用户名
    这里写图片描述
    6.点击开始体验
    这里写图片描述
    恭喜你,你已经成功在虚拟机中安装PhoenixOS系统,接下来请尽情享用PhoenixOS x86平台的安卓系统吧!!!

    4.体验系统

    我还在体验凤凰系统中,以后有啥发现或分享会更新此篇博客。
    如果博客中有啥错误或者您有啥分享欢迎在下面留言!!!
    感谢大家观看。

    展开全文
  • Phoenix 介绍和基本用法

    万次阅读 2018-06-14 14:49:41
    Phoenix是构建在HBase上的一个SQL层,能让我们用标准的JDBC APIs而不是HBase客户端APIs来创建表,插入数据和对HBase数据进行查询。Phoenix完全使用Java编写,作为HBase内嵌的JDBC驱动。Phoenix查询引擎会将SQL查询...

    Phoenix是构建在HBase上的一个SQL层,能让我们用标准的JDBC APIs而不是HBase客户端APIs来创建表,插入数据和对HBase数据进行查询。Phoenix完全使用Java编写,作为HBase内嵌的JDBC驱动。Phoenix查询引擎会将SQL查询转换为一个或多个HBase扫描,并编排执行以生成标准的JDBC结果集。
    Download:http://phoenix.apache.org/download.html,下载hbase对应版本的phoenix;解压bin.tar.gz包,拷贝phoenix server jar包到hbase集群的每个region server 的lib目录下,然后重启hbase 集群。
    1. 连接hbase:
    bin/sqlline.py 192.168.31.10:2181
    192.168.31.10:2181–> HBase集群配置zookeeper集群的ip地址和端口。
    利用!help 查看所有command。
    这里写图片描述
    2. 创建表:
    create table test (id varchar primary key,name varchar,age integer );
    phoenix:
    这里写图片描述
    hbase:
    这里写图片描述

    Hbase是区分大小写的,Phoenix 默认会把sql语句中的小写转换成大写,再建表,如果不希望转换,需要将表名,字段名等使用引号。Hbase默认phoenix表的主键对应到ROW,column family 名为0,也可以在建表的时候指定column family
    phoenix:
    这里写图片描述
    hbase:
    这里写图片描述
    3. 插入数据
    upsert into test(id,name,age) values(‘000001’,’liubei’,43);
    phoenix:
    这里写图片描述
    hbase:
    这里写图片描述
    4. 其他语法
    见官网 http://phoenix.apache.org/language/index.html

    5. 使用JDBC的方式来对HBase中的数据进行CRUD操作。
    phoenix-4.2.2-client.jar(可以在下载的phoenix-4.2.2-bin.tar.gz中找到该jar包)添加到项目的classpath中,将HBase集群的hbase-site.xml配置文件添加到项目的resources目录下。为了查看日志输出配置了一个简单的log4j.properties,也一并放到resources目录下。
    log4j.properties 内容如下:


    log4j.rootLogger=WARN, A1
    
    # A1 is set to be a ConsoleAppender.
    log4j.appender.A1=org.apache.log4j.ConsoleAppender
    
    # A1 uses PatternLayout.
    log4j.appender.A1.layout=org.apache.log4j.PatternLayout
    log4j.appender.A1.layout.ConversionPattern=%-4r [%t] %-5p %c %x - %m%n
       
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

    5.1 获得连接


    /**
      * project:hadoop-phoenix
      * file:BaseDB.java
      * time:2015年5月4日 下午2:19:57
      * description:
      */
    package cn.com.dimensoft.hadoop.phoenix.jdbc;
    
    import java.sql.Connection;
    import java.sql.DriverManager;
    
    /**
     * class: BaseDB
     * package: cn.com.dimensoft.hadoop.phoenix.jdbc
     * time: 2015年5月4日 下午2:19:57
     * description: 
     */
    public class BaseDB {
    
        /**
         * 
         * name:getConnection
         * time:2015年5月6日 下午2:07:06
         * description: get JDBC connection
         * @return connection
         */
        public static Connection getConnection() {
            try {
                // load driver
                Class.forName("org.apache.phoenix.jdbc.PhoenixDriver");
    
                // get connection
                // jdbc 的 url 类似为 jdbc:phoenix [ :<zookeeper quorum> [ :<port number> ] [ :<root node> ] ],
                // 需要引用三个参数:hbase.zookeeper.quorum、hbase.zookeeper.property.clientPort、and zookeeper.znode.parent,
                // 这些参数可以缺省不填而在 hbase-site.xml 中定义。
                return DriverManager.getConnection("jdbc:phoenix");
            } catch (Exception e) {
                e.printStackTrace();
                return null;
            }
        }
    
    }
    
       
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44

    5.2 创建表


    /**
         * 
         * name:create
         * time:2015年5月4日 下午2:58:31
         * description:create table
         */
        public static void create() {
            Connection conn = null;
            try {
                // get connection
                conn = BaseDB.getConnection();
    
                // check connection
                if (conn == null) {
                    System.out.println("conn is null...");
                    return;
                }
    
                // check if the table exist
                ResultSet rs = conn.getMetaData().getTables(null, null, "USER",
                        null);
                if (rs.next()) {
                    System.out.println("table user is exist...");
                    return;
                }
                // create sql
                String sql = "CREATE TABLE user (id varchar PRIMARY KEY,INFO.account varchar ,INFO.passwd varchar)";
    
                PreparedStatement ps = conn.prepareStatement(sql);
    
                // execute
                ps.execute();
                System.out.println("create success...");
    
            } catch (SQLException e) {
                e.printStackTrace();
            } finally {
                if (conn != null) {
                    try {
                        conn.close();
                    } catch (SQLException e) {
                        e.printStackTrace();
                    }
                }
            }
    
        }
    
       
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48

    5.3 插入数据


    /**
         * 
         * name:insert
         * time:2015年5月4日 下午2:59:11
         * description:
         */
        public static void upsert() {
    
            Connection conn = null;
            try {
                // get connection
                conn = BaseDB.getConnection();
    
                // check connection
                if (conn == null) {
                    System.out.println("conn is null...");
                    return;
                }
    
                // create sql
                String sql = "upsert into user(id, INFO.account, INFO.passwd) values('001', 'admin', 'admin')";
    
                PreparedStatement ps = conn.prepareStatement(sql);
    
                // execute upsert
                String msg = ps.executeUpdate() > 0 ? "insert success..."
                        : "insert fail...";
    
                // you must commit
                conn.commit();
                System.out.println(msg);
    
            } catch (SQLException e) {
                e.printStackTrace();
            } finally {
                if (conn != null) {
                    try {
                        conn.close();
                    } catch (SQLException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    
       
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45

    5.4 查询数据


    /**
         * 
         * name:query
         * time:2015年5月4日 下午3:58:12
         * description:query data
         */
        public static void query() {
    
            Connection conn = null;
            try {
                // get connection
                conn = BaseDB.getConnection();
    
                // check connection
                if (conn == null) {
                    System.out.println("conn is null...");
                    return;
                }
    
                // create sql
                String sql = "select * from user";
    
                PreparedStatement ps = conn.prepareStatement(sql);
    
                ResultSet rs = ps.executeQuery();
    
                System.out.println("id" + "\t" + "account" + "\t" + "passwd");
                System.out.println("======================");
    
                if (rs != null) {
                    while (rs.next()) {
                        System.out.print(rs.getString("id") + "\t");
                        System.out.print(rs.getString("account") + "\t");
                        System.out.println(rs.getString("passwd"));
                    }
                }
    
            } catch (SQLException e) {
                e.printStackTrace();
            } finally {
                if (conn != null) {
                    try {
                        conn.close();
                    } catch (SQLException e) {
                        e.printStackTrace();
                    }
                }
            }
    
        }
    
       
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51

    5.5 更新数据


    更新数据的操作与插入数据相同
       
    • 1

    5.6 删除数据


    /**
         * 
         * name:delete
         * time:2015年5月4日 下午4:03:11
         * description:delete data
         */
        public static void delete() {
    
            Connection conn = null;
            try {
                // get connection
                conn = BaseDB.getConnection();
    
                // check connection
                if (conn == null) {
                    System.out.println("conn is null...");
                    return;
                }
    
                // create sql
                String sql = "delete from user where id='001'";
    
                PreparedStatement ps = conn.prepareStatement(sql);
    
                // execute upsert
                String msg = ps.executeUpdate() > 0 ? "delete success..."
                        : "delete fail...";
    
                // you must commit
                conn.commit();
                System.out.println(msg);
    
            } catch (SQLException e) {
                e.printStackTrace();
            } finally {
                if (conn != null) {
                    try {
                        conn.close();
                    } catch (SQLException e) {
                        e.printStackTrace();
                    }
                }
            }
    
        }
    
       
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46

    5.7 删除表


    /**
         * 
         * name:drop
         * time:2015年5月4日 下午4:03:35
         * description:drop table
         */
        public static void drop() {
    
            Connection conn = null;
            try {
                // get connection
                conn = BaseDB.getConnection();
    
                // check connection
                if (conn == null) {
                    System.out.println("conn is null...");
                    return;
                }
    
                // create sql
                String sql = "drop table user";
    
                PreparedStatement ps = conn.prepareStatement(sql);
    
                // execute
                ps.execute();
    
                System.out.println("drop success...");
    
            } catch (SQLException e) {
                e.printStackTrace();
            } finally {
                if (conn != null) {
                    try {
                        conn.close();
                    } catch (SQLException e) {
                        e.printStackTrace();
                    }
                }
            }
    
        }
    
       
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43

    参考链接:https://blog.csdn.net/maomaosi2009/article/details/45582321

    展开全文
  • Phoenix

    千次阅读 2018-07-19 13:23:00
    1.打开Phoenix环境 在公司的Xshell上连接测试服务器之后,输入 [root@name01-test ~]# su hdfs [hdfs@name01-test root]$ sqlline.py data01-test Setting property: [incremental, false] Setting property: ...

    Phoenix是一个支持在HBase上进行SQL查询的引擎。由于HBase的语言和传统SQL有较大不同,不利于数据库开发者的迁移,因此Phoenix作为中间件,可以极大的提高数据开发者的开发效率。
    Phoenix官方文档:http://phoenix.apache.org/,这是目前最权威的Phoenix文档,可惜的是没有中文版;
    阿里云上的中文简介:https://help.aliyun.com/document_detail/53600.html?spm=a2c4g.11186623.6.581.EuG7gQ


    1.打开Phoenix环境
    在公司的Xshell上连接测试服务器之后,输入

    [root@name01-test ~]# su hdfs
    [hdfs@name01-test root]$ sqlline.py data01-test
    Setting property: [incremental, false]
    Setting property: [isolation, TRANSACTION_READ_COMMITTED]
    issuing: !connect jdbc:phoenix:data01-test none none org.apache.phoenix.jdbc.PhoenixDriver
    Connecting to jdbc:phoenix:data01-test
    SLF4J: Class path contains multiple SLF4J bindings.
    SLF4J: Found binding in [jar:file:/opt/cloudera/parcels/phoenix-4.8.0-cdh5.8.0/phoenix-4.8.1/phoenix-4.8.1-HBase-1.1-client.jar!/org/slf4j/impl/StaticLoggerBinder.class]
    SLF4J: Found binding in [jar:file:/opt/cloudera/parcels/CDH-5.15.0-1.cdh5.15.0.p0.21/jars/slf4j-log4j12-1.7.5.jar!/org/slf4j/impl/StaticLoggerBinder.class]
    SLF4J: See http://www.slf4j.org/codes.html#multiple_bindings for an explanation.
    18/07/19 13:21:04 WARN util.NativeCodeLoader: Unable to load native-hadoop library for your platform... using builtin-java classes where applicable
    Connected to: Phoenix (version 4.8)
    Driver: PhoenixEmbeddedDriver (version 4.8)
    Autocommit status: true
    Transaction isolation: TRANSACTION_READ_COMMITTED
    Building list of tables and columns for tab-completion (set fastconnect to true to skip)...
    92/92 (100%) Done
    Done
    sqlline version 1.1.9
    0: jdbc:phoenix:data01-test> !table
    +------------+--------------+-------------+---------------+----------+------------+----------------------------+-----------------+--------------+-----------------+---------------+---------------+-------------+
    | TABLE_CAT  | TABLE_SCHEM  | TABLE_NAME  |  TABLE_TYPE   | REMARKS  | TYPE_NAME  | SELF_REFERENCING_COL_NAME  | REF_GENERATION  | INDEX_STATE  | IMMUTABLE_ROWS  | SALT_BUCKETS  | MULTI_TENANT  | VIEW_STATEM |
    +------------+--------------+-------------+---------------+----------+------------+----------------------------+-----------------+--------------+-----------------+---------------+---------------+-------------+
    |            | SYSTEM       | CATALOG     | SYSTEM TABLE  |          |            |                            |                 |              | false           | null          | false         |             |
    |            | SYSTEM       | FUNCTION    | SYSTEM TABLE  |          |            |                            |                 |              | false           | null          | false         |             |
    |            | SYSTEM       | SEQUENCE    | SYSTEM TABLE  |          |            |                            |                 |              | false           | null          | false         |             |
    |            | SYSTEM       | STATS       | SYSTEM TABLE  |          |            |                            |                 |              | false           | null          | false         |             |
    |            |              | TEST        | TABLE         |          |            |                            |                 |              | false           | null          | false         |             |
    |            |              | TEST_TEST   | TABLE         |          |            |                            |                 |              | false           | null          | false         |             |
    +------------+--------------+-------------+---------------+----------+------------+----------------------------+-----------------+--------------+-----------------+---------------+---------------+-------------+
    0: jdbc:phoenix:data01-test> 
    

    2.Phoenix常用命令
    从Linux进入Phoenix环境:

    su hdfs
    sqlline.py data01-test

    显示所有表格:!table
    删除表格:drop table 表名;


    3.Phoenix的数据类型
    翻译自官方文档:http://phoenix.apache.org/language/datatypes.html
    INTEGER,整数,取值在-2147483648 to 2147483647,带符号四字节表示;
    UNSIGNED_INT,取值在0 to 2147483647;
    BIGINT,取值在-9223372036854775808 to 9223372036854775807,带符号八字节表示;
    UNSIGNED_LONG,取值在0 to 9223372036854775807;
    TINYINT,取值在 -128 to 127,带符号单字节;
    UNSIGNED_TINYINT,取值在0 to 127;
    SMALLINT,取值在-32768 to 32767,有符号两字节;
    UNSIGNED_SMALLINT,取值在0 to 32767,无符号两字节;
    FLOAT,取值在-3.402823466 E + 38 to 3.402823466 E + 38,有符号四字节;
    UNSIGNED_FLOAT,取值0 to 3.402823466 E + 38,无符号四字节;
    DOUBLE,-1.7976931348623158 E + 308 to 1.7976931348623158 E + 308;
    UNSIGNED_DOUBLE,0 to 1.7976931348623158 E + 308;
    DECIMAL,小数,可以指定DECIMAL(精度,比例),例如DECIMAL(10,2)的最大精度是38位,但是注意,在Phoenix中一般不给定括号中的值,直接DECIMAL就可以;
    BOOLEAN,取值为TRUE/FALSE,表示1/0;
    TIME,时间表征数据类型,格式为’yyyy-MM-dd hh:mm:ss’;
    DATE,日期表征数据类型,格式为’yyyy-MM-dd hh:mm:ss’,其日期和时间精度可达毫秒;
    TIMESTAMP,时间戳数据类型,数据类型 yyyy-MM-dd hh:mm:ss[.nnnnnnnnn];
    UNSIGNED_TIME,无符号的TIME;
    UNSIGNED_DATE,无符号的DATE;
    UNSIGNED_TIMESTAMP,无符号的TIMESTAMP;
    VARCHAR,长度可变的字符串,可用VARCHAR或VARCHAR(10),但在Phoenix中一般只用VARCHAR;
    CHAR,长度固定的字符串,可用CHAR或CHAR(10),但在Phoenix中一般只用CHAR;
    BINARY ,固定长度字节数列;
    VARBINARY ,可变长度字节数列;
    ARRAY,数组类型,仅支持一维数组;


    4.语法
    翻译自官方文档:http://phoenix.apache.org/language/index.html#hint
    SELECT,从一个或多个表格中获取数据。
    UPSERT,没有值的话,插入值;否则的话,更新值。
    UPSERT SELECT,没有值的话,插入值;否则的话,基于查询语句的结果插入行。
    DELETE,删除行。
    DECLARE CURSOR
    OPEN CURSOR
    FETCH NEXT
    CLOSE
    CREATE TABLE,创建表。
    DROP TABLE,删除表。
    CREATE FUNCTION
    DROP FUNCTION
    CREATE VIEW
    DROP VIEW
    CREATE SEQUENCE
    DROP SEQUENCE
    ALTER
    CREATE INDEX
    DROP INDEX
    ALTER INDEX
    EXPLAIN
    UPDATE STATISTICS
    CREATE SCHEMA
    USE
    DROP SCHEMA
    GRANT
    REVOKE
    Constraint
    Options
    Hint
    Scan Hint
    Cache Hint
    Index Hint
    Small Hint
    Seek To Column Hint
    Join Hint
    Serial Hint
    Column Def
    Table Ref
    Sequence Ref
    Column Ref
    Select Expression
    Select Statement
    Split Point
    Table Spec
    Aliased Table Ref
    Join Type
    Func Argument
    Class Name

    展开全文
  • Phoenix快速入门系列(2) | 一文教你如何使用Phoenix

    千次阅读 多人点赞 2020-06-29 09:23:48
      此篇为大家带来的是一文教你如何使用Phoenix。 目录一. Phoenix 表操作二. Phoenix 表映射1. Phoenix 表和 HBase 表的关系2 准备工作3. 视图映射4. 表映射5. 视图映射和表映射的对比与总结 一. Phoenix 表操作 ...
  • Phoenix5.0 安装部署

    千次阅读 2019-07-22 15:21:12
    文章目录概述Phoenix5.0 shell 安装Phoenix5.0 shell 使用使用Phoenix操作表phoenix shell下创建view映射hbase表 概述 现有hbase的查询工具有很多如:Hive,Tez,Impala,Shark/Spark,Phoenix等。phoenix是一个在...
  • 大数据-phoenix

    2020-09-27 11:39:24
    大数据-phoenix 由于Hbase当中的数据查询方式比较单一,查询形式比较固定,所以一般都会对Hbase实现二级索引的开发,通过二级索引去更加方便快速的查询Hbase当中的数据,我们也可以通过phoenix与Hbase整合的方式...
  • phoenix索引

    2021-02-22 15:38:19
    二级索引这个特性应该是大部分用户引入Phoenix主要考虑的因素之一。HBase因其历史原因只支持rowkey索引,当使用rowkey来查询数据时可以很快定位到数据位置。现实中,业务查询需求条件往往比较复杂,带有多个查询字段...
  • Phoenix版本:apache-phoenix-4.14.1-HBase-1.4-bin HBASE版本:hbase-1.4.2 上面的版本必须是对应的,否则会报错 2 Phoenix + HBase + Spark整合 A:安装HBASE,这里略,默认都会 B:Phoenix + HBASE整合,参考:ht...
  • Phoenix 5索引

    千次阅读 2019-08-03 16:39:03
    文章目录增删改查phoenix shell下创建view映射hbase表退出Phoenixpsql.py 执行外部SQL文件创建表导入数据复杂SQL:计数平均值聚合 Phoenix5.0 安装部署 搭建了Phoenix环境,本文介绍一下Phoenix的shell使用。 增删改...
  • HBase 高可用集群整合 Phoenix 配置 接上文:HBase 高可用集群配置 整合 phoenix 虽然简单,但是有坑。按照官网(http://phoenix.apache.org/installation.html )进行操作在新版本上基本不会成功! 首先确保你的...
  • Phoenix学习

    千次阅读 2019-01-04 00:22:51
    本文是一篇Phoenix综述文章,不断更新中。 0x01 Phoenix基础概念 1.1 Phoenix是什么 Phoenix最早是saleforce的一个开源项目,后来成为Apache基金的顶级项目。。 Phoenix是构建在HBase上的一个SQL层,能让我们...
  • 虽然HBase本身不支持SQL,但业界还是有现成的方案来支持,如Hive、Impala、Phoenix等。众多方案各有各的优势,本文主要对Phoenix作一个大概的介绍。 Phoenix中文翻译为凤凰, 其最早是Salesforce的一个开源项目,...
  • Phoenix的使用方式详解

    千次阅读 热门讨论 2019-12-28 10:53:13
    本篇博客小菌为大家分享的是关于Phoenix的使用方式与常用shell。         前文传送门:《Phoenix(凤凰)的安装介绍》 Phoenix使用      &n...
  • Phoenix 简单操作使用

    千次阅读 2019-12-27 21:08:28
    Phoenix可以有4种方式调用 批处理方式 命令行方式 GUI方式 JDBC调用方式 (1)批处理方式 A: 创建user_phoenix.sql文件 内容如下 CREATE TABLE IF NOT EXISTS user_phoenix ( state CHAR(2) NOT NULL, ...
  • 文章目录1.HBase与Phoenix简介2.HBase入们2.1 (重要)版本选择2.2 单点部署2.2.1 解压2.2.2 修改hbase-env.sh 配置2.2.3 修改hbase-site.sh 配置2.2.4 添加环境变量2.2.5 启动以及命令行使用2.3 HBase shell窗口命令...
  • Phoenix入门

    千次阅读 2021-05-27 17:02:22
    本文概述Phoenix
  • springboot集成phoenix,操作hbase

    千次阅读 2020-07-08 17:41:57
    文章目录前言1、版本要求1.1 对hbase版本的支持2、微服务集成2.1 创建gradle项目,添加依赖2.2 application.yml配置2.3 准备调试环境2.3.1 服务器配置2.3.2 本地配置3 Phoenix语法3.1 创建表3.2 删除表3.3 查询数据...
  •   此篇为大家带来的是一文教你如何在Phoenix中创建 HBase 二级索引。 目录一. HBase 的二级索引二. 配置 HBase 支持 Phoenix 创建二级索引三. Phoenix 创建索引1. Phoenix 索引分类2. 创建索引总结 一. HBase 的...
  • Phoenix4.7 操作手册

    千次阅读 2018-12-07 10:29:17
    Phoenix操作手册   Phoenix简介 Phoenix最早是saleforce的一个开源项目,后来成为Apache基金的顶级项目。 Phoenix是构建在HBase上的一个SQL层,能让我们用标准的JDBC APIs而不是HBase客户端APIs来创建表,插入...
  • phoenix使用总结

    2021-04-14 19:36:35
    phoenix映射HBase 默认情况下,直接在hbase中创建的表,通过phoenix是查看不到的。 如果要在phoenix中操作由hbase创建的表,则需要在phoenix中进行表的映射。 映射方式有两种:视图映射和表映射。 Phoenix创建的...
  • phoenix使用详解

    2021-03-13 17:10:37
    phoenix和hive类似,它也是一个工具,hive是在hadoop之上,phoenix是在hbase之上,也是Apache基金的顶级项目。phoenix是构建在HBase上的一个SQL层,能让我们用标椎的JDBC APIs而不是HBase客户端APIs来创建表、和对...
  • Kylin与Phoenix的区别

    2020-07-10 15:54:38
    与此同时,出现了越来越多的大数据技术帮助企业进行大数据分析,例如 Apache Hadoop,Hive,Spark,Presto,Drill,以及今天我们即将介绍的 Apache Kylin 和 Apache Phoenix 项目等,都是使用 SQL 语言就可以分析...
  • Phoenix命令及语法

    万次阅读 2018-04-12 17:16:32
    基本命令:首先sqlline.py lyy1,lyy2,lyy3,lyy4:2181登录到Phoenix的shell中,可以使用正常的SQL语句进行操作。!table查看表信息 !describe tablename可以查看表字段信息 !history可以查看执行的历史SQL !dbinfo !...
  • 计划总是赶不上变化,在实际开发中,需求总会不断变更,比如需求开始只需要在phoenix中创建5个字段就可以,但随着业务的变化,需要新增一个字段,某个字段的数据类型也需要改变,这时简单粗暴的方式就是删表重建,再...
  • Dbvisualizer 连接 Phoenix

    万次阅读 2020-08-09 15:38:03
    准备HBASE+Phoenix的环境、Dbvisualizer、和Phoenix驱动包(phoenix-xxx-client.jar) 1、创建Phoenix驱动 在Dbvisualizer中,依次选择Tools -> Driver Manager ->+(create a new driver) ,填写Name,URL ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 37,046
精华内容 14,818
关键字:

phoenix