
# 使用Phoenix轻客户端连接PhoenixQueryServer
#### 操作场景
MRS 3.6.0-LTS版本后，HBase服务安装PhoenixQueryServer实例后，支持通过Phoenix轻客户端进行连接。
#### 前提条件
- 已安装HBase客户端。
- 已创建组件业务用户，并绑定了具有创建HBase表权限的角色，具体操作请参考[创建HBase用户并绑定角色](https://support.huaweicloud.com/cmpntguide-lts-mrs/mrs_01_1608.html)。
 
#### 操作步骤
1. 以客户端安装用户，登录安装HBase客户端的节点。
2. 执行以下命令切换到客户端目录。 
   ```
   cd 客户端安装目录
   ```
   
   
3. 执行以下命令配置环境变量。 
   ```
   source bigdata_env
   ```
   
   
4. （可选）如果集群已启用Kerberos认证（安全模式），需执行以下命令认证当前用户，当前用户需要具有创建HBase表的操作权限：
   
   ```
   kinit 组件业务用户
   ```
   也可直接执行[5]，通过"**-p** *组件业务用户@集群系统域名* **-kt** *keytab文件路径"*命令指定用户。
   
   
5. 执行以下命令连接PhoenixQueryServer：
   
   - 集群已启用Kerberos认证（安全模式）
     ```
     sqlline-thin.py https://PhoenixQueryServer IP地址:Port [-p 组件业务用户@集群系统域名 -kt keytab文件路径]
     ```
     
   
   - 集群未启用Kerberos认证（普通模式）
     ```
     sqlline-thin.py http://PhoenixQueryServer IP地址:Port
     ```
     
   
   
   其中：
   - PhoenixQueryServer IP地址和端口可登录Manager界面，选择"集群 \> 服务 \> HBase \> 实例"，在实例列表获取任一PhoenixQueryServer的业务IP地址；选择"配置"，搜索"phoenix.queryserver.http.port"获取端口号。
   
   - -p（可选）：用于指定登录的用户名，格式为"*组件业务用户@集群系统域名* "，用户需具有创建HBase表的权限；集群系统域名可登录Manager界面，选择"系统 \> 权限 \> 域和互信"，查看"本端域"获取。
     如果已执行[4]认证了用户，连接PhoenixQueryServer可无需指定**-p** 和**-kt**参数。
     
   
   - -kt（可选）：登录的用户的keytab文件所在路径。在Manager界面，选择"系统 \> 权限 \> 用户"，在用户列表中选择"更多 \> 下载认证凭据"，解压后获得"user.keytab"文件，并上传至客户端所在节点的任意目录下。
   
   
   
   
6. 建立连接成功后即可执行Phoenix操作命令，例如，可执行以下命令查看Phoenix表： 
   ```
   !table
   ```
   
   
 
#### Sqlline常用语法及常用函数介绍
表1Sqlline常用语法 
| 命令                     | 描述          | 示例                                                                           |
|:---|:---|:---|
| **CREATE TABLE**       | 创建表。        | ``` CREATE TABLE MY_TABLE(id BIGINT not null primary key, name VARCHAR); ``` |
| **ALTER**              | 修改表/视图。     | ``` ALTER TABLE MY_TABLE DROP COLUMN name; ```                               |
| **DROP TABLE**         | 删除表。        | ``` DROP TABLE MY_TABLE; ```                                                 |
| **UPSERT VALUES**      | 插入/修改数据。    | ``` UPSERT INTO MY_TABLE VALUES(1,'abc'); ```                                |
| **SELECT**             | 查询数据。       | ``` SELECT * FROM MY_TABLE; ```                                              |
| **CREATE INDEX**       | 创建全局索引。     | ``` CREATE INDEX MY_IDX ON MY_TABLE(name); ```                               |
| **CREATE LOCAL INDEX** | 创建局部索引。     | ``` CREATE LOCAL INDEX MY_LOCAL_IDX ON MY_TABLE(id,name); ```                |
| **ALTER INDEX**        | 修改索引状态。     | ``` ALTER INDEX MY_IDX ON MY_TABLE DISABLE; ```                              |
| **DROP INDEX**         | 删除索引。       | ``` DROP INDEX MY_IDX ON MY_TABLE; ```                                       |
| **EXPLAIN**            | 显示执行计划。     | ``` EXPLAIN SELECT name FROM MY_TABLE; ```                                   |
| **CREATE SEQUENCE**    | 创建序列。       | ``` CREATE SEQUENCE MY_SEQUENCE; ```                                         |
| **DROP SEQUENCE**      | 删除序列。       | ``` DROP SEQUENCE MY_SEQUENCE; ```                                           |
| **CREATE VIEW**        | 创建视图。       | ``` CREATE VIEW MY_VIEW AS SELECT * FROM MY_TABLE; ```                       |
| **DROP VIEW**          | 删除视图。       | ``` DROP VIEW MY_VIEW; ```                                                   |
| **CREATE SCHEMA**      | 创建SCHEMA。   | ``` CREATE SCHEMA MY_SCHEMA; ```                                             |
| **USE**                | 修改默认SCHEMA。 | ``` USE MY_SCHEMA; ```                                                       |
| **DROP SCHEMA**        | 删除SCHEMA。   | ``` DROP SCHEMA MY_SCHEMA; ```                                               |
   
表2Sqlline常用函数 
| 函数类型 | 函数                    | 描述                                                                                                                                                                                             | 示例                                                       |
|:---|:---|:---|:---|
| 字符串  | **SUBSTR**            | 字符串截取。                                                                                                                                                                                         | SUBSTR('\[Hello\]', 2, 5)                                |
| 字符串  | **INSTR**             | 查询子串位置。                                                                                                                                                                                        | INSTR('Hello World', 'World')                            |
| 字符串  | **TRIM**              | 去除前后空格。                                                                                                                                                                                        | TRIM(' Hello ')                                          |
| 字符串  | **LTRIM**             | 去除左空格。                                                                                                                                                                                         | LTRIM(' Hello')                                          |
| 字符串  | **RTRIM**             | 去除右空格。                                                                                                                                                                                         | RTRIM('Hello ')                                          |
| 字符串  | **LPAD**              | 字符串左侧填充。                                                                                                                                                                                       | LPAD('John',30,'\*')                                     |
| 字符串  | **LENGTH**            | 获取字符串长度。                                                                                                                                                                                       | LENGTH('Hello')                                          |
| 字符串  | **UPPER**             | 字符串转大写。                                                                                                                                                                                        | UPPER('Hello')                                           |
| 字符串  | **LOWER**             | 字符串转小写。                                                                                                                                                                                        | LOWER('HELLO')                                           |
| 字符串  | **REVERSE**           | 字符串反转。                                                                                                                                                                                         | REVERSE('Hello')                                         |
| 字符串  | **REGEXP_SPLIT**      | 字符串分隔。                                                                                                                                                                                         | REGEXP_SPLIT('ONE,TWO,THREE', ',')                       |
| 字符串  | **REGEXP_REPLACE**    | 字符串替换。                                                                                                                                                                                         | REGEXP_REPLACE('abc123ABC', '\[0-9\]+', '#')             |
| 字符串  | **REGEXP_SUBSTR**     | 获取正则子串。                                                                                                                                                                                        | REGEXP_SUBSTR('na1-appsrv35-sj35', '\[\^-\]+')           |
| 聚合   | **AVG**               | 获取平均数。                                                                                                                                                                                         | AVG(X)                                                   |
| 聚合   | **COUNT**             | 获取数据条数。                                                                                                                                                                                        | COUNT(\*)                                                |
| 聚合   | **MAX**               | 获取最大值。                                                                                                                                                                                         | MAX(NAME)                                                |
| 聚合   | **MIN**               | 获取最小值。                                                                                                                                                                                         | MIN(NAME)                                                |
| 聚合   | **SUM**               | 数字求和。                                                                                                                                                                                          | SUM(X)                                                   |
| 聚合   | **STDDEV_POP**        | 标准差。                                                                                                                                                                                           | STDDEV_POP( X )                                          |
| 聚合   | **STDDEV_SAMP**       | 样板标准差。                                                                                                                                                                                         | STDDEV_SAMP( X )                                         |
| 聚合   | **NTH_VALUE**         | 分组后的第几个值。                                                                                                                                                                                      | NTH_VALUE( name, 2 ) WITHIN GROUP (ORDER BY salary DESC) |
| 时间   | **NOW**               | 获取当前时间（DATE类型）。                                                                                                                                                                                | NOW()                                                    |
| 时间   | **CURRENT_TIME**      | 获取当前时间（TIME类型）。                                                                                                                                                                                | CURRENT_TIME()                                           |
| 时间   | **CURRENT_** **DATE** | 获取当前时间（DATE类型）。                                                                                                                                                                                | CURRENT_DATE()                                           |
| 时间   | **TO_DATE**           | 字符串转DATE类型。                                                                                                                                                                                    | TO_DATE('1970-01-01', 'yyyy-MM-dd', 'GMT+1')             |
| 时间   | **TO_TIME**           | 字符串转TIME类型。                                                                                                                                                                                    | TO_TIME('1970-01-01', 'yyyy-MM-dd', 'GMT+1')             |
| 时间   | **TO_TIMESTAMP**      | 字符串转TIMESTAMP类型。                                                                                                                                                                               | TO_TIMESTAMP('1970-01-01', 'yyyy-MM-dd', 'GMT+1')        |
| 时间   | **YEAR**              | 获取年。                                                                                                                                                                                           | YEAR(TO_DATE('2015-6-05'))                               |
| 时间   | **MONTH**             | 获取月。                                                                                                                                                                                           | MONTH(TO_TIMESTAMP('2015-6-05'))                         |
| 时间   | **WEEK**              | 获取星期。                                                                                                                                                                                          | WEEK(TO_TIME('2010-6-15'))                               |
| 时间   | **HOUR**              | 获取小时。                                                                                                                                                                                          | HOUR(TO_TIMESTAMP('2015-6-05'))                          |
| 时间   | **MINUTE**            | 获取分钟。                                                                                                                                                                                          | MINUTE(TO_TIME('2015-6-05'))                             |
| 时间   | **SECOND**            | 获取秒。                                                                                                                                                                                           | SECOND(TO_DATE('2015-6-05'))                             |
| 数字   | **ROUND**             | 四舍五入（也可用于时间）。                                                                                                                                                                                  | ROUND(2.56)                                              |
| 数字   | **CEIL**              | 向上取整。                                                                                                                                                                                          | CEIL(2.34)                                               |
| 数字   | **FLOOR**             | 向下取整。                                                                                                                                                                                          | FLOOR(2.34)                                              |
| 数字   | **TRUNC**             | 向下取整（与**FLOOR**相同）。                                                                                                                                                                            | TRUNC(2.34)                                              |
| 数字   | **TO_NUMBER**         | 字符串转数字。                                                                                                                                                                                        | TO_NUMBER('-123.33')                                     |
| 数字   | **RAND**              | 获取随机数。                                                                                                                                                                                         | RAND()                                                   |
| 数学   | **ABS**               | 求绝对值。                                                                                                                                                                                          | ABS(-1)                                                  |
| 数学   | **SQRT**              | 公式： ![](https://support.huaweicloud.com/cmpntguide-lts-mrs/zh-cn_formulaimage_0000001444883521.png)  | SQRT(1.1)                                                |
| 数学   | **EXP**               | 公式： ![](https://support.huaweicloud.com/cmpntguide-lts-mrs/zh-cn_formulaimage_0000001445363177.png)   | EXP(-1)                                                  |
| 数学   | **POWER**             | 公式： ![](https://support.huaweicloud.com/cmpntguide-lts-mrs/zh-cn_formulaimage_0000001394403470.png)    | POWER(2, 3)                                              |
| 数学   | **LN**                | 公式： ![](https://support.huaweicloud.com/cmpntguide-lts-mrs/zh-cn_formulaimage_0000001445363181.png) | LN(3)                                                    |
| 数学   | **LOG**               | 公式： ![](https://support.huaweicloud.com/cmpntguide-lts-mrs/zh-cn_formulaimage_0000001445563185.png)  | LOG(2, 3)                                                |
| 数组   | **ARRAY_ELEM**        | 通过下标访问数组。                                                                                                                                                                                      | ARRAY_ELEM(ARRAY\[1,2,3\], 1)                            |
| 数组   | **ARRAY_PREPEND**     | 指定位置插入数据到数组。                                                                                                                                                                                   | ARRAY_APPEND(ARRAY\[1,2,3\], 4)                          |
| 数组   | **ARRAY_CAT**         | 连接数组。                                                                                                                                                                                          | ARRAY_CAT(ARRAY\[1,2\], ARRAY\[3,4\])                    |
| 数组   | **ARRAY_FILL**        | 数组填充。                                                                                                                                                                                          | ARRAY_FILL(1, 3)                                         |
| 数组   | **ARRAY_TO_STRING**   | 数组转字符串。                                                                                                                                                                                        | ARRAY_TO_STRING(ARRAY\['a','b','c'\], ',')               |
| 数组   | **ANY**               | 数组任意值满足条件。                                                                                                                                                                                     | 10 \> ANY(my_array)                                      |
| 数组   | **ALL**               | 数组所有值满足条件。                                                                                                                                                                                     | 10 \> ALL(my_array)                                      |
| 其他   | **MD5**               | 获取MD5码。                                                                                                                                                                                        | MD5(my_column)                                           |
| 其他   | **ENCODE**            | 编码字符串。                                                                                                                                                                                         | ENCODE(myNumber, 'BASE62')                               |
| 其他   | **DECODE**            | 解码字符串。                                                                                                                                                                                         | DECODE('000000008512af277ffffff8', 'HEX')                |
   
