HSQL

Hive的数据存储

　　1、Hive中所有的数据都存储在 HDFS 中，没有专门的数据存储格式（可支持Text，SequenceFile，ParquetFile，RCFILE等）
　　2、只需要在创建表的时候告诉 Hive 数据中的列分隔符和行分隔符，Hive 就可以解析数据。
　　3、Hive 中包含以下数据模型：DB、Table，External Table，Partition，Bucket。
　　　（1）：db：在hdfs中表现为${hive.metastore.warehouse.dir}目录下一个文件夹
　　　　（3）：external table：外部表, 与table类似，不过其数据存放位置可以在任意指定路径
　　　　（2）：table：在hdfs中表现所属db目录下一个文件夹
　　　　　　　　普通表: 删除表后, hdfs上的文件都删了
　　　　　　　　External外部表删除后, hdfs上的文件没有删除, 只是把文件删除了
　　　　（4）：partition：在hdfs中表现为table目录下的子目录
　　　　（5）：bucket：桶, 在hdfs中表现为同一个表目录下根据hash散列之后的多个文件, 会根据不同的文件把数据放到不同的文件中

1：Hive创建数据表：
# page_view是数据表的名称，注意hive的数据类型和java的数据类型类似，和mysql和oracle等数据库的字段类型不一致。
CREATE TABLE page_view(viewTime INT, userid BIGINT,
     page_url STRING, referrer_url STRING,
     ip STRING COMMENT 'IP Address of the User')
#COMMENT描述，可有可无的。
COMMENT 'This is the page view table'
# PARTITIONED BY指定表的分区，可以先不管。
PARTITIONED BY(dt STRING, country STRING)
# ROW FORMAT DELIMITED代表一行是一条记录，是自己创建的全部字段和文件的字段对应，一行对应一条记录。
ROW FORMAT DELIMITED
#FIELDS TERMINATED BY '01'代表一行记录中的各个字段以什么隔开，方便创建的数据字段对应文件的一条记录的字段。
   FIELDS TERMINATED BY '01'
# STORED AS SEQUENCEFILE;代表对应的文件类型。最常见的是SEQUENCEFILE（以键值对类型格式存储的）类型。TEXTFILE类型。
STORED AS SEQUENCEFILE;

如何开启MySQL的远程帐号（Navicat远程连接自己的mysql数据库）：
mysql> GRANT ALL PRIVILEGES ON *.* TO 'root'@'%' IDENTIFIED BY '123456' WITH GRANT OPTION;

再执行下面的语句，方可立即生效（修改的权限即时生效）。
mysql> FLUSH PRIVILEGES;

（1）all PRIVILEGES 表示赋予所有的权限给指定用户，这里也可以替换为赋予某一具体的权限，例如select,insert,update,delete,create,drop 等，具体权限间用“,”半角逗号分隔。
（2）*.* 表示上面的权限是针对于哪个表的，*指的是所有数据库，后面的 * 表示对于所有的表，由此可以推理出：对于全部数据库的全部表授权为“*.*”，对于某一数据库的全部表授权为“数据库名.*”，对于某一数据库的某一表授权为“数据库名.表名”。
（3）root 表示你要给哪个用户授权，这个用户可以是存在的用户，也可以是不存在的用户。
（4）192.168.3.132   表示允许远程连接的 IP 地址，如果想不限制链接的 IP 则设置为“%”即可。
（5）123456 为用户的密码。

2：创建好数据表，开始插入数据
create table tb_order(id int,name string,memory string,price double) row format delimited fields terminated by ' ';
在/home/hadoop/目录下面phoneorder.data
[root@slaver3 hadoop]# vim phoneorder.data   10010    小米1    2G    1999 /   10011    小米2    4G    1999
开始导入数据（或者使用hadoop的命令将正确格式数据上传到对应的目录）
hive> load data local inpath '/home/hadoop/hivetest/phoneorder.data' into table tb_order;
3: 使用hive的查询语句进行查询操作
hive (myhive)> select * from tb_order;
4：external外部表，优点，做数据分析的时候，有的数据是业务系统产生的，或者读或者写这个文件，如果的默认的路径，即在配置文件里面写好了，
如果做分析的时候数据表导数据，如果将数据表移动了，，业务系统再读这个文件就不存在了，这个时候使用外部表，外部表不要求数据非到默认的路径下面去，数据可以摆放到任意的hdfs路径下面；
//external外部表
//使用关键字EXTERNAL
CREATE EXTERNAL TABLE 数据表名称(id int, name string,
     ip STRING,
     country STRING)
ROW FORMAT DELIMITED
FIELDS TERMINATED BY ' '
STORED AS TEXTFILE

#location指定所在的位置：切记，重点。
LOCATION '/external/user';
TO:
[root@slaver3 hadoop]# cd /home/hadoop/hivetest/
[root@slaver3 hivetest]# cp phoneorder.data phoneorder4.data
[root@slaver3 hivetest]# hadoop fs -mkdir /hive_ext
[root@slaver3 hivetest]# hadoop fs -put phoneorder4.data /hive_ext

hive> create external table tb_order_ext(id int,name string,memory string,price double)
    > row format delimited
    > fields terminated by ' '
    > location '/hive_ext';
查看扩展数据表的数据表结构       1 hive> desc extended tb_log;
格式化查看扩展表的数据表结构   1 hive> desc formatted tb_log;

5：创建分区表（分区的好处是可以帮助你统计的时候少统计一些数据，加速数据统计）：
hive> create table tb_part(sNo int,sName string,sAge int,sDept string)
    > partition //拿不准的单词，可以tab一下进行提示，并不会影响你创建表；谢谢
partition     partitioned   partitions
    > partitioned by (part string)
    > row format delimited
    > fields terminated by ','
    > stored as textfile;
OK
Time taken: 0.351 seconds

将本地的数据上传到hive上面：
1 hive> load data local inpath '/home/hadoop/data_hadoop/tb_part' overwrite into table tb_part partition (part='20171210');
6 hive> load data local inpath '/home/hadoop/data_hadoop/tb_part' overwrite into table tb_part partition (part='20171211');
11 hive> show par
13 hive> show partition
15 hive> show partitions tb_part;

6：创建带桶的数据表，然后将本地创建好测试数据上传到hive上面：
1 hive> create table if not exists tb_stud(id int,name string,age int)
2     > partitioned by(clus string)
3     > clustered by(id) sorted by(age) into 2 buckets #分桶，根据id进行分桶，分成2个桶。
4     > row format delimited
5     > fields terminated by ',';
8 hive> load data local inpath '/home/hadoop/data_hadoop/tb_clustered' overwrite into table tb_stud partition (clus='20171211');

7：修改表，增加/删除分区
hive> alter table tb_stud add partition(clus='20171217');
hive> alter table tb_stud drop partition(clus='20171217');
hive> show partitions tb_stud;

8：重命名表：
1 hive> show tables;
2 hive> alter table tb_user rename to tb_user_copy;

9：增加/更新列
1 hive> desc tb_user;
hive> alter table tb_user add columns(age int);
hive> alter table tb_user replace columns(id int,name string,birthday string);

10：Load，操作只是单纯的复制/移动操作，DML操作
说明：
1、Load 操作只是单纯的复制/移动操作，将数据文件移动到 Hive 表对应的位置。
2、filepath：
　　相对路径，例如：project/data1
　　绝对路径，例如：/user/hive/project/data1
　　包含模式的完整 URI，列如：
　　hdfs://namenode:9000/user/hive/project/data1
3、LOCAL关键字
　　如果指定了 LOCAL， load 命令会去查找本地文件系统中的 filepath。
　　如果没有指定 LOCAL 关键字，则根据inpath中的uri[如果指定了 LOCAL，那么：
　　load 命令会去查找本地文件系统中的 filepath。如果发现是相对路径，则路径会被解释为相对于当前用户的当前路径。
　　load 命令会将 filepath中的文件复制到目标文件系统中。目标文件系统由表的位置属性决定。被复制的数据文件移动到表的数据对应的位置。

　　如果没有指定 LOCAL 关键字，如果 filepath 指向的是一个完整的 URI，hive 会直接使用这个 URI。否则：如果没有指定　　schema 或者 authority，Hive 会使用在 hadoop 配置文件中定义的 schema 和 authority，fs.default.name 指定了 Namenode 的 URI。
　　如果路径不是绝对的，Hive 相对于/user/进行解释。
　　Hive 会将 filepath 中指定的文件内容移动到 table （或者 partition）所指定的路径中。]查找文件

4、OVERWRITE 关键字
如果使用了 OVERWRITE 关键字，则目标表（或者分区）中的内容会被删除，然后再将 filepath 指向的文件/目录中的内容添加到表/分区中。
如果目标表（分区）已经有一个文件，并且文件名和 filepath 中的文件名冲突，那么现有的文件会被新文件所替代。

11：Hive的insert操作：

hive> load data local inpath '/home/hadoop/data_hadoop/tb_stud' overwrite into table tb_stud partition (clus='20171211');
hive> select * from tb_stud where clus='20171211';
hive> insert overwrite table tb_stud partition(clus='20171218')
   > select id,name,age from tb_stud where clus='20171211';
hive> select * from tb_stud where clus='20171218';


hive> show partitions tb_stud;
hive> alter table tb_stud add partition(clus='20171212');
hive> alter table tb_stud add partition(clus='20171213');
hive> alter table tb_stud add partition(clus='20171214');
hive> from tb_stud
     > insert overwrite table tb_stud partition(clus='20171213')
     > select id,name,age where clus='20171211'
     > insert overwrite table tb_stud partition(clus='20171214')
     > select id,name,age where clus='20171211';
hive> select * from tb_stud where clus='20171213';
hive> select * from tb_stud where clus='20171214';

12：导出表数据
1、导出文件到本地。
说明：
数据写入到文件系统时进行文本序列化，且每列用^A来区分，为换行符。用more命令查看时不容易看出分割符，可以使用: sed -e 's/x01/|/g' filename[]来查看。
hive> insert overwrite local directory '/home/hadoop/data_hadoop/get_tb_stud'
      > select * from tb_stud;
2、导出数据到HDFS。
   hive> insert overwrite directory 'hdfs://192.168.199.130:9000/user/hive/warehouse/tb_stud_get'
       > select * from tb_stud;
   hive> dfs -ls /user/hive/warehouse/tb_stud_get;

13:SELECT，基本的Select操作
1、order by 会对输入做全局排序，因此只有一个reducer，会导致当输入规模较大时，需要较长的计算时间。
2、sort by不是全局排序，其在数据进入reducer前完成排序。因此，如果用sort by进行排序，并且设置mapred.reduce.tasks>1，则sort by只保证每个reducer的输出有序，不保证全局有序。
3、distribute by根据distribute by指定的内容将数据分到同一个reducer。
4、Cluster by 除了具有Distribute by的功能外，还会对该字段进行排序。因此，常常认为cluster by = distribute by + sort by
5、分桶表的最大的意思：最大的作用是用来提高join操作的效率；
6、思考这个问题：
　　select a.id,a.name,b.addr from a join b on a.id = b.id;
　　如果a表和b表已经是分桶表，而且分桶的字段是id字段
　　做这个join操作时，还需要全表做笛卡尔积吗？答案：不需要，因为相同的id就在同一个桶里面。

14：删除hive的内部表和外部表的区别：
　　删除内部表是将元数据（TABL表），以及hdfs上面的文件夹以及文件一起删除；
　　删除外部表只是删除元数据（TABL表），hdfs上面的文件夹以及文件不删除。

15：创建一个新表根据老表（用来做一些中间结果的存储，再做后一步的处理，）：
注意：用于创建一些临时表存储中间结果；
hive> create table tb_order_new
    > as
    > select id,name,memory,price
    > from tb_order;

16：insert from select   通过select语句批量插入数据到别的表（用于向临时表中追加中间结果数据）：
hive> create table tb_order_append(id int,name string,memory string,price double)
     > row format delimited
     > fields terminated by ' ';
hive> insert overwrite table tb_order_append
     > select * from tb_order;
hive> select * from tb_order_append;

17：PARTITION ，分区表（partition），分区统计，可以对数据操作加快速度：
查询分区：hive> show partitions part;　　 #show partitions 数据表名称;
删除分区：hive> alter table part drop partition(date='20180512');
添加分区：hive> alter table part add partition(date='20180512');
将数据导入这个新建的分区里面（所谓分区就是在文件夹下面创建一个文件夹，把数据放到这个文件夹下面），如下所示：
hive> load data local inpath '/home/hadoop/hivetest/phoneorder.data' into table tb_order_part partition(month='201401');
hive> load data local inpath '/home/hadoop/hivetest/phoneorder2.data' into table tb_order_part partition(month='201402');

18：write to hdfs，将结果写入到hdfs的文件中：
hive> insert overwrite local directory '/home/hadoop/hivetest/test.txt'
     > select * from tb_order_part
     > where month="201401";

19：Hive的Join使用：
语法结构
join_table:
table_reference JOIN table_factor [join_condition]
| table_reference {LEFT|RIGHT|FULL} [OUTER] JOIN table_reference join_condition
| table_reference LEFT SEMI JOIN table_reference join_condition
Hive 支持等值连接（equality joins）、外连接（outer joins）和（left/right joins）。Hive 不支持非等值的连接，因为非等值连接非常难转化到 map/reduce 任务。
另外，Hive 支持多于 2 个表的连接。
写 join 查询时，需要注意几个关键点：
1. 只支持等值join
例如：
SELECT a.* FROM a JOIN b ON (a.id = b.id)
SELECT a.* FROM a JOIN b
    ON (a.id = b.id AND a.department = b.department)
是正确的，然而:
SELECT a.* FROM a JOIN b ON (a.id>b.id)
是错误的。

2. 可以 join 多于 2 个表。
例如
SELECT a.val, b.val, c.val FROM a JOIN b
    ON (a.key = b.key1) JOIN c ON (c.key = b.key2)
如果join中多个表的 join key 是同一个，则 join 会被转化为单个 map/reduce 任务，例如：
SELECT a.val, b.val, c.val FROM a JOIN b
    ON (a.key = b.key1) JOIN c
    ON (c.key = b.key1)
被转化为单个 map/reduce 任务，因为 join 中只使用了 b.key1 作为 join key。
SELECT a.val, b.val, c.val FROM a JOIN b ON (a.key = b.key1)
JOIN c ON (c.key = b.key2)
而这一 join 被转化为 2 个 map/reduce 任务。因为 b.key1 用于第一次 join 条件，而 b.key2 用于第二次 join。

3．join 时，每次 map/reduce 任务的逻辑：
    reducer 会缓存 join 序列中除了最后一个表的所有表的记录，再通过最后一个表将结果序列化到文件系统。这一实现有助于在 reduce 端减少内存的使用量。实践中，应该把最大的那个表写在最后（否则会因为缓存浪费大量内存）。例如：
SELECT a.val, b.val, c.val FROM a
    JOIN b ON (a.key = b.key1) JOIN c ON (c.key = b.key1)
所有表都使用同一个 join key（使用 1 次 map/reduce 任务计算）。Reduce 端会缓存 a 表和 b 表的记录，然后每次取得一个 c 表的记录就计算一次 join 结果，类似的还有：
SELECT a.val, b.val, c.val FROM a
    JOIN b ON (a.key = b.key1) JOIN c ON (c.key = b.key2)
这里用了 2 次 map/reduce 任务。第一次缓存 a 表，用 b 表序列化；第二次缓存第一次 map/reduce 任务的结果，然后用 c 表序列化。

4．LEFT，RIGHT 和 FULL OUTER 关键字用于处理 join 中空记录的情况
例如：
SELECT a.val, b.val FROM
a LEFT OUTER JOIN b ON (a.key=b.key)
对应所有 a 表中的记录都有一条记录输出。输出的结果应该是 a.val, b.val，当 a.key=b.key 时，而当 b.key 中找不到等值的 a.key 记录时也会输出:
a.val, NULL
所以 a 表中的所有记录都被保留了；
“a RIGHT OUTER JOIN b”会保留所有 b 表的记录。

Join 发生在 WHERE 子句之前。如果你想限制 join 的输出，应该在 WHERE 子句中写过滤条件——或是在 join 子句中写。这里面一个容易混淆的问题是表分区的情况：
SELECT a.val, b.val FROM a
LEFT OUTER JOIN b ON (a.key=b.key)
WHERE a.ds='2009-07-07' AND b.ds='2009-07-07'
会 join a 表到 b 表（OUTER JOIN），列出 a.val 和 b.val 的记录。WHERE 从句中可以使用其他列作为过滤条件。但是，如前所述，如果 b 表中找不到对应 a 表的记录，b 表的所有列都会列出 NULL，包括 ds 列。也就是说，join 会过滤 b 表中不能找到匹配 a 表 join key 的所有记录。这样的话，LEFT OUTER 就使得查询结果与 WHERE 子句无关了。解决的办法是在 OUTER JOIN 时使用以下语法：
SELECT a.val, b.val FROM a LEFT OUTER JOIN b
ON (a.key=b.key AND
      b.ds='2009-07-07' AND
      a.ds='2009-07-07')
这一查询的结果是预先在 join 阶段过滤过的，所以不会存在上述问题。这一逻辑也可以应用于 RIGHT 和 FULL 类型的 join 中。

Join 是不能交换位置的。无论是 LEFT 还是 RIGHT join，都是左连接的。
SELECT a.val1, a.val2, b.val, c.val
FROM a
JOIN b ON (a.key = b.key)
LEFT OUTER JOIN c ON (a.key = c.key)
先 join a 表到 b 表，丢弃掉所有 join key 中不匹配的记录，然后用这一中间结果和 c 表做 join。这一表述有一个不太明显的问题，就是当一个 key 在 a 表和 c 表都存在，但是 b 表中不存在的时候：整个记录在第一次 join，即 a JOIN b 的时候都被丢掉了（包括a.val1，a.val2和a.key），然后我们再和 c 表 join 的时候，如果 c.key 与 a.key 或 b.key 相等，就会得到这样的结果：NULL, NULL, NULL, c.val