ToB企服应用市场:ToB评测及商务社交产业平台

标题: 【大数据】一篇认识Hive [打印本页]

作者: 立聪堂德州十三局店    时间: 2024-11-16 00:15
标题: 【大数据】一篇认识Hive
一、数据堆栈

1.1、数据堆栈概念


  1. 其分析的数据来自于企业各种数据源。
  2. 企业中常见的数据源:
  3.         RDBMS关系型数据库--->业务数据
  4.         log file----->日志文件数据
  5.         爬虫数据
  6.         其他数据
复制代码

  1. 其分析的结果给外部各种数据应用(Data application)来使用。
  2. Data visualization(DV)数据可视化
  3. Data Report 数据报表
  4. Data Mining(DM) 数据挖掘
  5. Ad-Hoc 即席查询
  6.         即席查询(Ad Hoc)是用户根据自己的需求,灵活的选择查询条件,系统能够根据用户的选择生成相应的统计报表。即席查询与普通应用查询最大的不同是普通的应用查询是定制开发的,而即席查询是由用户自定义查询条件的。
复制代码

1.2、数据堆栈核心特性


1.3、数据库和数据堆栈的区别


  1. Transaction 事务 面向事务支持事务
  2. OLTP系统注重的是数据安全、完整、响应效率。通常指的就是RDBMS关系型数据库。
  3.   #面向事务 支持事务
  4.   #RDBMS: MySQL ORACLE
  5.   #注意 不是NoSQL数据库 没有事务支持: Redis HBase
复制代码

  1.   Analytical 分析 面向分析支持分析
  2.   OLAP更注重的是数据吞吐量
  3.   主要指的是数据仓库、数据集市(小型数据仓库):Apache Hive、Apache Impala
复制代码

  1.   如果把RDBMS只用作数据分析工作,就是OLAP系统。
  2.   
  3.   关系型数据库只要从事的是数据分析的工作,就可以看做是OLAP系统
  4.   但是Hive不可以作为OLTP使用因为其不具备事务功能.
复制代码

1.4、数据堆栈分层架构[紧张]


  1. 其数据来自于各个不同的数据源 临时存储 和数据源解耦合之间有差异一般不直接用于分析
复制代码

  1. 其数据来自于ODS经过层层的ETL变成各种模型的数据.数据干净.规则统一
  2. 基于各种模型开展各种分析
  3. 企业中根据业务复杂度 继续在DW中继续划分子层。 存储大量的中间结果。其数据来自于ODS经过层层ETL得出 企业中可以根据需求在DW中继续分层。
复制代码

  1. 最终消费DW数据的各种应用。
复制代码


1.5、ETL和ELT

E: 数据抽取 将多个数据源中的数据抽取到临时存储空间(内存, 磁盘)
T: 数据转换 将数据举行清洗或转换,使其干净同一,满足数据分析的使用要求
L: 数据加载 将数据加载到数据堆栈中,待其他业务部门使用.
ETL: 先将数据抽取到临时位置大概内存中,举行数据转换处理,最终结果加载到数仓

二、Apache Hive

2.1、Hive的概念


  1.   为什么说Hive是基于Hadoop的呢?
  2.   
  3.   #作为一款数据仓库软件,应该要具备哪些能力?
  4.   具备存储数据的能力
  5.   具备分析数据的能力
  6.   
  7.   Hive作为数仓软件,当然具备上述两种能力?
  8.   #Hive使用Hadoop HDFS作为数据存储系统
  9.   #Hive使用Hadoop MapReduce来分析数据
  10.   
  11.   基于此说Hive是基于Hadoop的数仓软件。
复制代码
总结:
   hive是一个数仓管理工具,是基于hadoop的数仓软件
hive既不负责数据的存储,也不负责数据的盘算.
hive的作用:
  
  什么是结构化数据?
   可以通过行索引和列索引定位一个数据的数据结构,类似于excel表数据或则sql数据库数据
结构化数据:
  1. 1, 小明, 12
  2. 2, 小芳, 15
  3. 3, 小绿, 22
复制代码
表:
  学号姓名年龄1小明122小芳153小绿22  结构化数据映射表时须要提取hive中的元数据.
  2.2、Hive的架构组件(非常紧张)



  1.   所谓的客户端指的是给用户一种方式编写Hive SQL
  2.   目前常见的客户端:CLI(命令行接口 shell)、Web UI、JDBC|ODBC
复制代码

  1.   hive的核心
  2.   完成从接受HQL到编译成为MR程序的过程。
  3.   sql解释 编译 校验 优化 制定计划
复制代码

  1.   元数据存储。 描述性数据。
  2.   对于hive来说,元数据指的是表和文件之间的映射关系。
复制代码

  1.   HDFS  存储文件
  2.   MapReduce 计算数据
  3.   YARN  程序运行的资源分配
复制代码

  1.   Hive不是分布式软件。只需要在一台机器上部署Hive服务即可;
  2.   Hive的分布式处理能力是借于Hadoop完成的。HDFS分布式存储  MapReduce分布式计算。
  3.   hive不是分布式软件,但是可以借助hadoop完成分布式的存储和计算任务
复制代码
总结: 其实hive的架构一共就三大部分: 客户端 驱动步伐 元数据服务
2.3、Hive和Mysql的区别


三、Hive安装

3.1、Metadata、metastore

回顾: hdfs的元数据
   元数据: 形貌数据的数据
hdfs中存储一个文件,文件中的数据内容就是我们想要获取的内容.
如果想要获取这个内容,我们就须要知道这个文件的相关形貌信息
例如: 路径,大小,创建修改时间,名称,block块的数目, 位置 …
  1. # Metadata 元数据
  2. 对于hive来说,元数据主要指的是表和文件之间的映射关系。
  3. 元数据也是数据,存储在哪里呢?Hive当下支持两种地方存储元数据。
  4.         1、存储在Hive内置的RDBSM中,Apache Derby(内存级别轻量级关系型数据库)  
  5.                 Derby数据库主要是为了让程序员测试hive的执行使用,正常开发中不会使用该数据库
  6.         2、存储在外界第三方的RDBMS中,比如:MySQL。  企业中常用的方式。
  7. # metastore 元数据访问服务
  8. 专门用于操作访问metadata的一种服务,对外暴露服务地址给各个不同的客户端使用访问Hive的元数据。
  9. 并且某种程度上保证了metadata的安全。
复制代码
思考:hive中的元数据都包罗什么?
   hive中我们使用元数据构建表,用来形貌结构化数据,就是结构化数据的映射.
库名,表名, 字段名, 字段范例, 数据存储位置…
hive映射的过程,就是使用元数据建表,通过元数据存储的数据位置,从hdfs中获取数据,依次填写到表中,形成表数据,再使用sql语句举行查询.
  思考:hive为什么不将元数据存储在hdfs中呢?
   hive举行元数据管理时,我们须要快速创建表结构,并且频繁举行元数据的增删改查, hdfs中的数据不支持随机修改.且增删改的服从较低,不适互助为hive的元数据存储服务出现
  3.2、Hive的安装摆设模式






  1.     1、元数据使用外置的RDBMS,常见使用最多的是MySQL。
  2.     2、metastore服务单独配置  单独手动启动  全局唯一。
  3.     这样的话各个客户端只能通过这一个metastore服务访问Hive.
  4.     企业生产环境中使用的模式,支持多客户端远程并发操作访问Hive.
复制代码


3.3、Hive的长途模式摆设安装

3.3.1、安装Hadoop

   启动hive之前,须要保证Hadoop启动且服务正常可用。
  1. 1、等待安全模式结束启动Hive
  2. 2、在Hadoop中设置用户代理,注意3台机器都需要修改,重启生效
  3. vim etc/hadoop/core-site.xml
  4. <property>
  5.     <name>hadoop.proxyuser.root.hosts</name>
  6.     <value>*</value>
  7. </property>
  8. <property>
  9.     <name>hadoop.proxyuser.root.groups</name>
  10.     <value>*</value>
  11. </property>
复制代码
3.3.2、安装MySQL

   主要考虑的就是MySQL Hive版本的兼容性 和jdbc驱动版本
在Centos7情况下如何安装MySQL
仅在node1中安装了mysql所以我们选择node1举行hive的安装
  3.3.3、安装Hive (选择node1安装)

  1. #apache-hive-3.1.2-bin.tar.gz
  2. 上传到/export/software 解压到  /export/server
  3. cd /export/software
  4. tar -zxvf apache-hive-3.1.2-bin.tar.gz -C ../server
复制代码

  1.   cd /export/server/apache-hive-3.1.2-bin/
  2.   rm -rf lib/guava-19.0.jar
  3.   cp /export/server/hadoop-3.3.0/share/hadoop/common/lib/guava-27.0-jre.jar ./lib/
复制代码

  1.   cd /export/server/apache-hive-3.1.2-bin/conf
  2.   mv hive-env.sh.template hive-env.sh
  3.   
  4.   vim hive-env.sh
  5.   
  6.   
  7.   export HADOOP_HOME=/export/server/hadoop-3.3.0
  8.   export HIVE_CONF_DIR=/export/server/apache-hive-3.1.2-bin/conf
  9.   export HIVE_AUX_JARS_PATH=/export/server/apache-hive-3.1.2-bin/lib
复制代码

  1.   <configuration>
  2.   <!-- 存储元数据mysql相关配置 -->
  3.   <property>
  4.           <name>javax.jdo.option.ConnectionURL</name>
  5.           <value>jdbc:mysql://node1:3306/hive3?createDatabaseIfNotExist=true&amp;useSSL=false&amp;useUnicode=true&amp;characterEncoding=UTF-8</value>
  6.   </property>
  7.   
  8.   <property>
  9.           <name>javax.jdo.option.ConnectionDriverName</name>
  10.           <value>com.mysql.jdbc.Driver</value>
  11.   </property>
  12.   
  13.   <property>
  14.           <name>javax.jdo.option.ConnectionUserName</name>
  15.           <value>root</value>
  16.   </property>
  17.   
  18.   <property>
  19.           <name>javax.jdo.option.ConnectionPassword</name>
  20.           <value>123456</value>
  21.   </property>
  22.   
  23.   <!-- H2S运行绑定host -->
  24.   <property>
  25.       <name>hive.server2.thrift.bind.host</name>
  26.       <value>node1</value>
  27.   </property>
  28.   
  29.   <!-- 远程模式部署metastore metastore地址 -->
  30.   <property>
  31.     <name>hive.metastore.uris</name>
  32.       <value>thrift://node1:9083</value>
  33.   </property>
  34.   
  35.   <!-- 关闭元数据存储授权  -->
  36.   <property>
  37.     <name>hive.metastore.event.db.notification.api.auth</name>
  38.       <value>false</value>
  39.   </property>
  40.   </configuration>
  41.   
复制代码

  1.   mysql-connector-java-5.1.32.jar
复制代码

  1.   cd /export/server/apache-hive-3.1.2-bin/
  2.   
  3.   bin/schematool -initSchema -dbType mysql -verbos
  4.   # 初始化成功会在mysql中创建74张表
复制代码



  1.   hadoop fs -mkdir /tmp
  2.   hadoop fs -mkdir -p /user/hive/warehouse
  3.   hadoop fs -chmod g+w /tmp
  4.   hadoop fs -chmod g+w /user/hive/warehouse
复制代码
四、Hive 服务的启动[紧张]

4.1、metastore服务


  1.   #前台启动
  2.   /export/server/apache-hive-3.1.2-bin/bin/hive --service metastore
  3.   
  4.   #前台启动开启debug日志
  5.   /export/server/apache-hive-3.1.2-bin/bin/hive --service metastore --hiveconf hive.root.logger=DEBUG,console  
  6.   
  7.   #前台启动关闭方式  ctrl+c结束进程
复制代码

  1. nohup /export/server/apache-hive-3.1.2-bin/bin/hive --service metastore &
  2. #后台挂起启动 结束进程
  3. 使用jps查看进程 使用kill -9 杀死进程
  4. #nohup 命令,在默认情况下(非重定向时),会输出一个名叫 nohup.out 的文件到当前目录下
复制代码
注意: 日志文件存储在启动该服务时使用的工作目录中的 nohup.out文件下的.

  1.   vim /etc/profile
  2.   
  3.   # 在文件末尾添加如下内容
  4.   #HIVE_HOME
  5.   export HIVE_HOME=/export/server/hive
  6.   export PATH=$PATH:$HIVE_HOME/bin  
复制代码

  1.   source /etc/profile
复制代码

  1.   # 前台启动
  2.   hive --service metastore
  3.   
  4.   # 后台启动
  5.   nohup hive --service metastore &
复制代码
4.2、Hive的客户端


   lsof -i:10000
  五、Hive初体验


总结:
     六、Apache Hive SQL-DDL、DML

   DDL : 数据界说语言 (操作表, 操作库, 操作字段) 给数据搭建一个框架,等候数据填入
DML : 数据操作语言 (数据记录的增删改操作) 数据库数据记录的写入操作
DCL : 数据控制语言 (用户权限,表权限,库权限, 事务级别, 数据库相关配置等.) 所有控制,设置数据库的操作方式
DQL : 数据查询语言 (数据的查询操作) 数据库数据记录的读取操作
  6.1、 DataGrip毗连hive数据堆栈

1.点击Apache driver,跳转到驱动设置页面

2.点击加号,进入自界说jar包位置的选择

4. 选择驱动地点位置,点击ok 即可配置本地驱动

5.回到datasource,选择刚才操作的毗连,点击测试

测试成功后即可毗连完成.
检测毗连是否成功的方法: 检察数据毗连中是否可以精确显示数据堆栈的名称.

6.2、Hive SQL

6.2.1、Hive数据范例


  1. 整数类型: int
  2. 浮点型: double
  3. 字符串类型: string
  4. 布尔型: boolean
  5. 复合数据类型:
  6. map: 类似于字典,但是字典中键值对的数据类型要保持一致
  7. array: 类似于列表,但是只能存储相同数据类型的内容
  8. struct: 结构体(偶尔会用到)
  9. 在hive中数据都是写在文件中的,所占用的空间大小已经固定,使用哪些数据类型就不那么重要了
复制代码
6.2.2、建库/表


  1. -- 1.创建数据库
  2. -- create database 数据库名称;
  3. create database db_test;
  4. -- 再次创建同名数据库会报错, 所以我们需要增加安全性判断条件 if not exists
  5. create database if not exists db_test;
  6. -- 在hive中 database 和 schema 作用完全一样,记住一个就可以了,但是别人写的时候我们要认识
  7. create schema db_test1;
  8. -- 2. 查看所有的数据库
  9. show databases;
  10. -- 3. 使用数据库
  11. use db_test;
  12. -- 4. 查看当前正在使用的数据库
  13. select current_database();
  14. -- 5. 查看数据库的相关元数据信息
  15. desc database db_test;
  16. -- 6.创建一个数据库指定存储位置
  17. create database db_test2 location '/tmp/test';
  18. desc database db_test2;
  19. -- 7. 删除数据库
  20. drop database db_test;
  21. -- bigdata_db is not empty. One or more tables exist. 非空数据库无法被删除
  22. -- 如果想要删除非空数据库,要使用cascade (慎用)
  23. drop database bigdata_db cascade;
复制代码

  1. -- 1. 创建数据表
  2. -- 格式: create table 表名 (字段信息);
  3. create table test_db.students
  4. (
  5.     id   int,
  6.     name string,
  7.     age  int
  8. );
  9. -- 2. 如果该数据库中已经有该名称的表,将会报错,所以我们要添加安全性判断 if not exists
  10. create table if not exists test_db.students(
  11.     id int,
  12.     name string
  13. );
  14. -- 3. 查看数据表相关的元数据信息
  15. desc test_db.students;
  16. -- 4. 查看数据库中全部数据表的名称
  17. show tables in test_db;
  18. -- 5. 清空数据表
  19. --  does not support these operations.  在hive中不支持随机删除
  20. -- delete from test_db.students;
  21. -- 可以使用, 注意 table不能省略
  22. truncate table test_db.students;
  23. -- 6. 删除数据表, 有没有数据都可以删除该表
  24. drop table test_db.students;
  25. drop table test_db.person2;
复制代码
6.2.3、Hive读写HDFS上文件[重点]

  1. create external(外部表)  table if not exists 表名 (
  2.     id int,
  3.     name string
  4. )
  5. partitioned by name (分区表)
  6. cluster by name sorted by id into num(分桶表)
  7. row format delimited  (序列化类型)
  8. fields terminated by ',' (字段分隔符)
  9. collection items terminated by '-' (元素分隔符)
  10. map keys terminated by ':' (键值分隔符)
  11. tblproperties '' 表的属性信息
  12. ;
复制代码

   Deserializer: 可以明白为将数据从磁盘中读取到内存中的过程
Serializer :可以明白为将数据从内存中写入到磁盘中的操作
  
6.2.4、内部表、外部表[重点]

   内部表: hive完全拥有该表中数据记录和元数据的操作权限,删除该表时,数据记录和元数据全部销毁
外部表: hive只拥有该表元数据的操作权限,不具备数据记录的操作权限,删除该表时,数据记录文件依然存在,但是元数据被全部销毁了.
  



6.3、Hive的分区表[重中之重]


6.4、Hive分桶表(分簇表)[重中之重]

  1. CLUSTERED BY xxx INTO N BUCKETS
  2. --根据xxx字段把数据分成N桶
  3. --根据表中的字段把数据文件成为N个部分
  4. t_user(id int,name string);
  5. --1、根据谁分?
  6. CLUSTERED BY xxx ;  xxx必须是表中的字段
  7. --2、分成几桶?
  8. N BUCKETS   ;N的值就是分桶的个数
  9. --3、分桶的规则?
  10. clustered by id into 3 bucket
  11. hashfunc(分桶字段)  %  N bucket  余数相同的来到同一个桶中
  12. 1、如果分桶的字段是数字类型的字段,hashfunc(分桶字段)=分桶字段本身
  13. 2、如果分桶的字段是字符串或者其他字段,hashfunc(分桶字段) = 分桶字段.hashcode
复制代码
6.4.2、分桶的创建及加载

  1. -- 创建一个分桶表,使用的分桶字段是表中已有的字段,必须用括号括起来,不需要书写数据类型.
  2. CREATE TABLE test.t_usa_covid19_bucket
  3. (
  4.     count_date string,
  5.     county     string,
  6.     state      string,
  7.     fips       int,
  8.     cases      int,
  9.     deaths     int
  10. )
  11. clustered by (state) into 5 buckets
  12. row format delimited fields terminated by ',';
  13. -- 查看表中的元数据
  14. describe formatted test.t_usa_covid19_bucket;
  15. -- 使用已有的数据表,将数据读取出来,然后把数据从内存中写入到分桶表中.
  16. -- 1. 先创建一个不分桶的表
  17. CREATE TABLE itheima.t_usa_covid19
  18. (
  19.     count_date string,
  20.     county     string,
  21.     state      string,
  22.     fips       int,
  23.     cases      int,
  24.     deaths     int
  25. )
  26. row format delimited fields terminated by ',';
  27. -- 2. 向未分桶表中添加数据  直接将数据上传到未分桶表中即可
  28. -- 此处直接使用web页面上传,开发中不要这样操作
  29. -- 3. 读取未分桶表中的全部数据,写入到分桶表中(这个指令会走MR任务,所以速度比较慢)
  30. -- 格式: insert into 目标表名  查询集(完整的select语句)
  31. -- 注意: 被插入数据的表中的字段数据量,和字段类型,以及字段顺序,要与读取出来额查询集中完全相同.
  32. insert into test.t_usa_covid19_bucket
  33. select *
  34. from test.t_usa_covid19;
  35. -- 4. 查询分桶表中的数据是否加载成功
  36. select *
  37. from test.t_usa_covid19_bucket;
  38. -- 走mr任务时,由于要生成5个数据文件,会执行5个reduce任务
  39. -- 分桶表的分桶规则: 哈希取模法/哈希取余法   取模就是取余数,  例如 7 / 2  商 3 余  1  此时取模结果就是1
  40. -- 规则: 将分桶字段值取哈希值,然后按照分桶规则模以桶数. 根据余数不同分到不同的桶内
  41. -- 哈希算法: 这个是一个散列函数,不需要了解其底层怎么计算的,我们只要知道这个算法可以将所有的数据计算为一个唯一的数值即可.
  42. -- 一个值无论进行多少次哈希计算,最终结果都是相同的.
  43. select hash('测试'); -- 汉字的哈希值多为负数
  44. select hash('abc'); -- 字母符号的哈希值多为正数
  45. select hash(1); -- 整数的哈希值就是数字本身
  46. select hash(-5.1); -- 浮点型的哈希值是一个计算后的整数
  47. -- 由于New York 和 Florida 的哈希值与5进行取模后值相等,所以在同一个分桶中.
  48. select hash('New York'); -- 1382994575
  49. select hash('Florida'); -- 898707645
复制代码
6.4.5、分桶的总结


6.5、Hive SQL–DDL其他操作


6.6、Hive DML 数据操纵语言


  1. --1. 建表student_local 用于演示从本地加载数据
  2. create table student_local
  3. (
  4.     num  int,
  5.     name string,
  6.     sex  string,
  7.     age  int,
  8.     dept string
  9. ) row format delimited fields terminated by ',';
  10. -- 本地其实说的就是node1 也就是hive服务部署到哪一个服务器,这个服务器的Linux系统就是本地文件系统
  11. -- 从本地加载到hive表中的数据,会复制一份加载到hdfs上,本地数据不会清空
  12. load data local inpath '/root/hive_data/students.txt' into table student_local;
  13. -- 2. 建表student_HDFS  用于演示从HDFS加载数据到非分区表
  14. create table student_HDFS
  15. (
  16.     num  int,
  17.     name string,
  18.     sex  string,
  19.     age  int,
  20.     dept string
  21. ) row format delimited fields terminated by ',';
  22. -- 在hdfs中创建一个hive_data目录
  23. -- hadoop fs -mkdir /test/hive_data
  24. -- 将linux中的students.txt文件上传到hdfs中
  25. -- hadoop fs -put hive_data/students.txt /test/hive_data
  26. -- 将hdfs上的数据内容加载到student_HDFS表中
  27. load data inpath 'hdfs://node1:8020/test/hive_data/students.txt' into table student_HDFS;
  28. -- 再次加载数据时students.txt文件消失,因为使用loaddata 从hdfs向表中加载数据时为移动该数据.
  29. load data inpath '/test/hive_data/students.txt' into table student_HDFS;
  30. -- 3. 建表student_HDFS_b  用于演示从HDFS加载数据到分桶表
  31. create table student_HDFS_b
  32. (
  33.     num  int,
  34.     name string,
  35.     sex  string,
  36.     age  int,
  37.     dept string
  38. )
  39.     clustered by (num) into 3 buckets
  40.     row format delimited fields terminated by ',';
  41. -- 从hdfs中向分桶表中添加数据
  42. load data inpath '/test/hive_data/students.txt' into table student_HDFS_b;
  43. -- 4. 建表student_HDFS_p 用于演示从HDFS加载数据到分区表
  44. create table student_HDFS_p
  45. (
  46.     num  int,
  47.     name string,
  48.     sex  string,
  49.     age  int,
  50.     dept string
  51. ) partitioned by (country string) row format delimited fields terminated by ',';
  52. -- hdfs中向分区表中添加数据.必须指定分区值否则无法添加
  53. load data inpath '/test/hive_data/students.txt' into table student_HDFS_p partition (country = 'BJ');
  54. -- 5. 向表中覆盖数据
  55. -- 默认使用into table 是追加数据
  56. load data local inpath '/root/hive_data/students.txt' into table student_local;
  57. select *
  58. from student_local;
  59. -- 加载三次一共有66条数据
  60. -- 如果需要覆盖数据可以使用 overwrite 关键字
  61. load data local inpath '/root/hive_data/students.txt' overwrite into table student_local;
  62. select *
  63. from student_local; -- 覆盖成功后,一共有22条数据
复制代码

  1. -- 创建一张源表student
  2. drop table if exists student;
  3. create table student
  4. (
  5.     num  int,
  6.     name string,
  7.     sex  string,
  8.     age  int,
  9.     dept string
  10. )
  11.     row format delimited
  12.         fields terminated by ',';
  13. -- 将 student_HDFS表中的数据插入到student表中, 并且将每一个人的年龄增加一岁
  14. insert into student
  15. select num, name, sex, age + 1 as age, dept
  16. from student_hdfs;
  17. select *
  18. from student;
  19. -- 将查询到的数据插入到指定的表中还可以使用 create table as
  20. create table student_c as
  21. select num, name, sex, age + 1 as age, dept
  22. from student_hdfs;
  23. select *
  24. from student_c;
  25. -- 注意:
  26. -- 1. create table 创建的表不能存在, insert into 可以给表追加数据
  27. -- 2. create table as 的方法执行效率比insert into select 块很多, 因为create table 是DDL语句, 而insert into select 是DML语句
  28. -- 底层实现时, create table as 是将数据一次写入, insert into select 是一行一行写入.
  29. -- 多重插入
  30. -- 读取一次数据,插入多次,此时插入数据的效率会有所提升
  31. create table source_table
  32. (
  33.     id   int,
  34.     name string
  35. ) row format delimited fields terminated by ',';
  36. create table test_insert1
  37. (
  38.     id int
  39. ) row format delimited fields terminated by ',';
  40. create table test_insert2
  41. (
  42.     name string
  43. ) row format delimited fields terminated by ',';
  44. -- 向 source_table里导入数据
  45. load data local inpath '/root/hive_data/students.txt' into table source_table;
  46. -- 查询数据内容
  47. select * from source_table;
  48. -- 将 id 插入到 test_insert1表中
  49. insert into test_insert1 select id from source_table;
  50. -- 将 name 插入到 test_insert2表中
  51. insert into test_insert2 select name from source_table;
  52. -- 上述插入方式,读取了两次source_table表 也插入了两次, 但是两次读取的是同一张表
  53. -- 使用多重插入方法就可以实现一次读取,多次插入
  54. from source_table
  55. insert overwrite table test_insert1 select id
  56. insert overwrite table test_insert2 select name;
复制代码

  1. -- 1. 从hdfs中导出数据到hdfs中的指定目录下
  2. insert overwrite directory '/test/output_dir' select * from student_local;
  3. -- 查询数据源数据是否存在, 导出数据时,不会移动,修改,删除原数据.
  4. select * from student_local;
  5. -- 2. 导出数据时指定分隔符
  6. insert overwrite directory '/test/output_dir' row format delimited fields terminated by '❤' select * from student_local;
  7. -- 3. 导出数据时,会将目录中的全部数据清空
  8. insert overwrite directory '/test' row format delimited fields terminated by ',' select * from student_local;
  9. -- 4. 将数据导出到hive服务所在的linux系统中
  10. insert overwrite local directory '/root/hive_data' select * from student_local;
  11. -- 注意: 没有insert into directory这种写法
  12. -- 在开发中我们更多的会使用ETL工具或者数据采集工具进行数据导出. 例如 kettle, sqoop
复制代码
七、Apache Hive SQL-DQL、参数配置与函数

7.1、Hive SQL–DQL-Select

7.1.1、select语法树

  1. -- 1. 基础查询
  2. select *
  3. from test.student_local;
  4. select num, name
  5. from test.student_local;
  6. select name, age + 10
  7. from test.student_local;
  8. select name, 1, 2, 3, 4
  9. from test.student_local;
  10. -- 2. 条件查询
  11. select *
  12. from test.student_local
  13. where age > 20;
  14. select *
  15. from test.student_local
  16. where sex = '女';
  17. select *
  18. from test.student_local
  19. where age > 20
  20.   and sex = '女';
  21. select *
  22. from test.student_local
  23. where age between 18 and 20; -- 这个范围中包含18和20
  24. select *
  25. from test.student_local
  26. where age in (18, 20);
  27. select *
  28. from test.student_local
  29. where name like '李%';
  30. select *
  31. from test.student_local
  32. where name is null;
  33. -- 3.聚合查询
  34. select count(*)
  35. from test.student_local;
  36. select max(age)
  37. from test.student_local;
  38. -- 4.分组查询
  39. select sex, max(age)
  40. from test.student_local
  41. group by sex;
  42. select dept, count(1)
  43. from test.student_local
  44. group by dept;
  45. -- 5. 分组后筛选
  46. select sex, max(age)
  47. from test.student_local
  48. group by sex
  49. having max(age) > 20;
  50. select dept, count(1) as total
  51. from test.student_local
  52. group by dept
  53. having total > 3;
  54. -- 6. 排序函数
  55. select *
  56. from test.student_local
  57. order by age; -- 升序
  58. select *
  59. from test.student_local
  60. order by age desc; -- 降序
  61. -- 7. 分页查询
  62. select * from test.student_local limit 2;
  63. select * from test.student_local limit 3, 3;
复制代码
7.2.2、CLUSTER BY分桶查询

  1. -- 1. 对查询到的数据进行分桶排序
  2. -- 普通查询
  3. select * from student;
  4. -- 分桶查询
  5. select * from student cluster by num;
  6. -- 问题: 是否分桶 结果完全相同,使用了cluster by 也没有明显的效果
  7. -- 原因: 分桶的数量与reducetask的数量有关,如果没有设置reducetask 则默认为1个
  8. -- 解决办法: 手动设置reducetask数量 , 如果该值为-1,则根据查询语句规则自动定义reduce数量.
  9. set mapreduce.job.reduces;
  10. set mapreduce.job.reduces = 3; -- 设置reducetask数量为3
  11. -- 再次分桶查询
  12. -- 思考:分桶查询可以查询非分桶表么? 分桶查询和原表是否分桶没有任何关系,是将数据查询后才进行分桶规则判断的,所以原数据是否分桶都没关系.
  13. select * from student cluster by num;
  14. -- 观察发现,将num哈希取余后,根据余数不同,将数据记录存放在的不同的桶中, 有3个reduce任务,就产生了三个分桶
  15. -- 在每个桶的内部对于数据进行了升序排列
  16. -- 使用order by 不分桶直接排序
  17. select * from student order by num;
  18. -- order by 又叫做全局排序,无论reducetask数量是几,最终我们只会使用一个reducetask
  19. -- 在数据量较大时,该reduce任务的任务量巨大,所以开发时我们一般不建议使用order by , 如果非要使用, 我们会配合 where, 或者limit 进行使用.
  20. -- 思考: cluster by可以指定升序降序么?  不可以,只能使用默认的升序排列方式.
复制代码
7.3.3、DISTRIBUTE BY+SORT BY(记住)

  1. -- 普通查询
  2. select *
  3. from student;
  4. -- 分桶查询 cluster by
  5. select *
  6. from student cluster by num;
  7. set mapreduce.job.reduces =2;
  8. -- 将使用distribute by + sort by 将指定不同的字段为分桶字段和排序字段.
  9. select *
  10. from student distribute by dept;
  11. select *
  12. from student distribute by dept sort by num;
  13. select *
  14. from student distribute by num sort by age desc;
  15. -- 结论:
  16. -- 1. distribute by 只负责分桶工作
  17. -- 2. sort by 负责将分桶的结果进行桶内排序
  18. -- 3. 当分桶字段和排序字段为同一个字段,且排序规则为升序时, cluster by >>> distribute by num sort by
复制代码
7.4.4、union联合查询 [紧张且简单]

  1. -- union 联合查询,联合查询和join相似,只不过join时左右连接,union是上下连接
  2. -- union可以将两个查询集上下连接到一个查询集(虚拟表结构)中
  3. -- 1. 查询年龄大于20岁的女生
  4. select *
  5. from student
  6. where age > 20
  7.   and sex = '女';
  8. -- 2. 查询年龄小于20岁的男生
  9. select *
  10. from student
  11. where age < 20
  12.   and sex = '男';
  13. -- 3. 使用union联合查询将上述两个查询集链接到一起
  14. -- union 联合查询,无论如何都会走mr程序
  15. -- 无论联合查询前是什么顺序,联合后都会重新排序,且顺序无规律.
  16. -- 如果需要排序,可以联合查询之后,对其结果统一排序
  17. select *
  18. from student
  19. where age > 20
  20.   and sex = '女'
  21. union
  22. select *
  23. from student
  24. where age < 20
  25.   and sex = '男'
  26. order by age;
  27. -- 4. 使用联合查询将第二步的数据连接两次,最终有多少条记录???? 原始数据有6条
  28. -- union 联合查询后一共有6条数据
  29. -- 因为union 联合查询 如果不加任何修饰符 默认等价于 union distinct  默认去重(所有字段值均相同)
  30. select *
  31. from student
  32. where age < 20
  33.   and sex = '男'
  34. union
  35. select *
  36. from student
  37. where age < 20
  38.   and sex = '男';
  39. -- 如果我们不希望union自动去重 可以使用union all
  40. select *
  41. from student
  42. where age < 20
  43.   and sex = '男'
  44. union all
  45. select *
  46. from student
  47. where age < 20
  48.   and sex = '男';
  49. -- 5. 思考: union联合查询时,上下两个表中的字段数量和类型是否必须完全相同???  数据类型必须相同, 数据数量也必须相同
  50. -- select num, name from student
  51. -- union
  52. -- select name, num from student;
  53. -- select num, name
  54. -- from student
  55. -- union
  56. -- select num, name, age
  57. -- from student;
  58. -- 总结:
  59. -- 1. union联合查询就是将上下两张表连接在一起
  60. -- 2. union联合查询会打乱联合之前的排序.所以一般联合之后要重新排序
  61. -- 3. union联合查询后会自动去重.如果不需要去重,则使用union all
  62. -- 4. union联合查询时上下两张表数据类型必须相同, 数据数量也必须相同
复制代码
7.5.5、CTE表达式(记住最简单的调用形式即可)

  1. -- 使用select 语句查询一个结果集,使用with as 语法将其临时保存并命名,在当前sql语句中可以查询使用,sql语句结束,结果集释放.
  2. -- 格式: with 临时表名 as (select结果集)  select 查询语句
  3. with t1 as (select * from student)
  4. select *
  5. from t1;
  6. -- 需求: 获取与年龄最大的两个女生在相同部门的男生信息
  7. -- 子查询:
  8. select *
  9. from student
  10. where sex = '男'
  11.   and dept in (select dept from student where sex = '女' order by age desc limit 2);
  12. -- CTE表达式
  13. with top_2nv_dept as (select dept from student where sex = '女' order by age desc limit 2)
  14. select s.*
  15. from student s
  16.          join top_2nv_dept t on s.dept = t.dept
  17. where sex = '男';
  18. -- CTE表达式链式调用
  19. -- 我们在CTE表达式中可以一次创建多个临时表,且后创建的临时表,可以调用先次创建的临时表
  20. with q1 as (select * from student where num = 95002),
  21.      q2 as (select num, name, age from q1)
  22. select *
  23. from (select num from q2) a;
  24. -- 在同一个select 语句中,可以使用所有的临时表
  25. with q1 as (select num, name from student where sex = '男' and age > 20),
  26.      q2 as (select num, name from student where sex = '女' and age < 20)
  27. select *
  28. from q1
  29. union
  30. select *
  31. from q2;
  32. -- 思考: CTE表达式在sql语句结束后还能否调用到之前的临时表呢? 不行
  33. -- select * from q1;
  34. set mapreduce.job.reduces;
复制代码
7.2、Hive SQL join查询(左毗连,内毗连)

7.2.1、Hive支持join语法

  1. --Join语法练习 建表
  2. drop table if exists test.employee_address;
  3. drop table if exists test.employee_connection;
  4. drop table if exists test.employee;
  5. --table1: 员工表
  6. CREATE TABLE test.employee
  7. (
  8.     id     int,
  9.     name   string,
  10.     deg    string,
  11.     salary int,
  12.     dept   string
  13. ) row format delimited
  14.     fields terminated by ',';
  15. --table2:员工家庭住址信息表
  16. CREATE TABLE test.employee_address
  17. (
  18.     id     int,
  19.     hno    string,
  20.     street string,
  21.     city   string
  22. ) row format delimited
  23.     fields terminated by ',';
  24. --table3:员工联系方式信息表
  25. CREATE TABLE test.employee_connection
  26. (
  27.     id    int,
  28.     phno  string,
  29.     email string
  30. ) row format delimited
  31.     fields terminated by ',';
  32. -- 给表添加数据
  33. -- hadoop fs -put hive_data/employee.txt /user/hive/warehouse/test.db/employee
  34. -- hadoop fs -put hive_data/employee_address.txt /user/hive/warehouse/test.db/employee_address
  35. -- hadoop fs -put hive_data/employee_connection.txt /user/hive/warehouse/test.db/employee_connection
  36. -- 查询表中的数据是否添加成功
  37. select *
  38. from test.employee;
  39. select *
  40. from test.employee_address;
  41. select *
  42. from test.employee_connection;
  43. -- 1. 内连接  inner join
  44. -- 内连接将左表和右表中的指定字段内进行匹配,保留匹配成功的数据记录,忽略没有匹配成功的数据.
  45. select *
  46. from test.employee e
  47.          inner join test.employee_address ea
  48.                     on e.id = ea.id;
  49. -- 内连接中 inner可以省略
  50. select *
  51. from test.employee e
  52.          join test.employee_address ea
  53.               on e.id = ea.id;
  54. -- 2. 左外连接  left outer join
  55. -- 左连接将左表和右表中的指定字段进行匹配,保留左表中全部的数据,右表中的数据匹配成功则保留,匹配不成功则填充null
  56. select *
  57. from test.employee e
  58.          left outer join test.employee_address ea
  59.                          on e.id = ea.id;
  60. -- 外连接中可以省略outer
  61. select *
  62. from test.employee e
  63.          left join test.employee_address ea
  64.                    on e.id = ea.id;
  65. -- 3. 右外连接  right outer join
  66. -- 右连接将左表和右表中的指定字段进行匹配,保留右表中全部的数据,左表中的数据匹配成功则保留,匹配不成功则填充null
  67. select *
  68. from test.employee e
  69.          right outer join test.employee_address ea
  70.                           on e.id = ea.id;
  71. -- 外连接中可以省略outer
  72. select *
  73. from test.employee e
  74.          right join test.employee_address ea
  75.                     on e.id = ea.id;
  76. -- 4. 全连接  full join
  77. -- 全连接将左表和右表中的指定字段进行匹配,保留左表和右表中的全部数据,如果匹配成功则保留数据,不成功则填充null
  78. select *
  79. from test.employee e
  80.          full join test.employee_address ea on e.id = ea.id;
  81. -- 5. 左半连接 left semi join
  82. -- 其实就是左表和右表进行内连接, 但是仅可以获取到左表中匹配成功的数据,右表全部记录将被删除
  83. select *
  84. from test.employee e
  85.          left semi
  86.          join test.employee_address ea on e.id = ea.id;
  87. -- 左半连接,在开发中使用的场景与内连接比较相似,但是左半连接指向效率更高,因为只获取左表中的部分数据.
  88. -- 6. 交叉连接
  89. -- 交叉连接其实就是进行笛卡尔积计算, 左表中的每一条记录,依次和右表中的每一条进行匹配,物品匹配是否成功都保留.
  90. select *
  91. from test.employee e
  92.          cross join test.employee_address ea;
复制代码
7.2.2、join查询优化及注意事项


7.3、Hive Shell下令行[用的不多但十分紧张]

   批处理:一次毗连,一次交互, 实行竣事断开毗连
交互式处理:保持持续毗连, 不停交互
注意:如果说hive的shell客户端 指的是第一代客户端bin/hive
hive客户端其实是shell下令行控制hive的一种方式,是原生shell脚本与服务端的交互
而第二代客户端bin/beeline属于JDBC客户端 不是shell。
beeline是将数据发送给jdbc驱动,由驱动指挥hive完成指令
  
7.4、Hive内置运算符[明白]

  1. -- 1. 查看所有的内置运算符
  2. show functions;
  3. -- 2. 查看运算符的含义
  4. desc function +;
  5. desc function `current_timestamp`;
  6. -- 3. 查看函数或运算符的使用方法
  7. desc function extended `current_timestamp`;
  8. desc function extended sum;
  9. desc function extended avg;
  10. desc function extended concat;
复制代码
  1. -- hive中的关系运算符
  2. -- 1. 比较运算符: = > < >= <= != <>
  3. select 1 > 2;
  4. -- 2. 空值判断 :  is null | is not null
  5. -- select * from student where num is null;
  6. select null is not null; -- flase
  7. select 'null' is not null;
  8. -- null
  9. -- null 可以使用=判断么?  不可以
  10. -- select null = null;  -- null 和任何数据比较,判断都为空
  11. -- 3. 模糊查询
  12. select '江湖再见' like '%湖%';
  13. -- 模糊查询在hive中很少使用,因为效率较低
  14. -- 4. 正则匹配 -- 就是一个字符串的匹配规则
  15. select 'testdemo' rlike 'testdemo';
  16. select 'testdemo' rlike '.*de.*';
  17. select '13932627450' rlike '1[3-9]\\d{9}';
  18. -- 在正则表达式中使用\要使用两个,才能输出\
  19. -- 5. regexp 也是正则匹配和rlike完全相同
  20. select 'testdemo' regexp '.*de.*';
  21. -- hive中的算数运算符
  22. -- 1. + - * / % div
  23. -- 11 / 2 = 商 5 余 1
  24. select 11 % 2; -- 1  取余
  25. select 11 div 2;
  26. -- 2. 按位与操作 -- 同一个数位两个数据都为1则结果为1, 否则为0
  27. -- 4 >>> 0100
  28. -- 8 >>> 1000
  29. -- 结果   0000
  30. select 4 & 8;
  31. select 7 & 9;
  32. -- 7 >>> 0111   9 >>> 1001
  33. -- 3. 按位或操作 -- 同一个数位两个数据有任意一个为1则结果为1, 否则为0
  34. select 4 | 8; -- >>> 1100
  35. select 7 | 9;
  36. -- >>> 1111
  37. -- 4. 按位异或  -- 同一个数位两个数据若不同则结果为1, 否则结果为0
  38. select 4 ^ 8; -- >>> 1100
  39. select 7 ^ 9;
  40. -- >>> 1110
  41. -- 异或的其他用法
  42. -- 同一个数字连续异或两次相同的数字还是原数字
  43. select 4 ^ 8 ^ 8; -- 4
  44. select 8 ^ 4 ^ 4; -- 8
  45. -- hive中的逻辑运算
  46. -- 1. and 逻辑与 -- 同真即真
  47. select true and false;
  48. select true and true;
  49. -- 2. or 逻辑或  -- 同假即假
  50. select true or false;
  51. select true or true;
  52. select false or false;
  53. -- 3. not 逻辑非 -- 真假互换
  54. select not true;
  55. select not false;
复制代码
八、Hive函数

8.1、函数的分类

  1. -- UDF : 一进一出
  2. select round(12.444, 2);
  3. select unix_timestamp('2020-11-12 12:00:00');
  4. -- UDAF : 多进一出  聚合函数
  5. select avg(age) from student;
  6. -- UDTF : 一进多出  高阶函数
  7. select explode(`array`(1,2,3,4));
复制代码
8.1.1、内置的函数(build in func)

   所谓的内置指的是hive开发好,可以直接上手使用的;
  
  
8.1.2、用户界说函数(user-defined function)

   用户编程实现函数的逻辑在hive中使用。
  
  1. #1、UDF(User-Defined-Function)普通函数 一进一出  输入一行数据输出一行数据
  2. 0: jdbc:hive2://node1:10000> select split("allen woon hadoop"," ");
  3. +----------------------------+--+
  4. |            _c0             |
  5. +----------------------------+--+
  6. | ["allen","woon","hadoop"]  |
  7. +----------------------------+--+
  8. #2、UDAF(User-Defined Aggregation Function)聚合函数,多进一出 输入多行输出一行
  9. count sum max  min  avg
  10. #3、UDTF(User-Defined Table-Generating Functions)表生成函数 一进多出 输入一行输出多行
  11. explode 、parse_url_tuple
复制代码

九、Hive的函数高阶应用

9.1、explode函数[紧张] & lateral view 侧视图[紧张]

   explode属于UDTF函数,表天生函数,输入一行数据输出多行数据。
侧视图的原理是将UDTF的结果构建成一个类似于视图的表,然后将原表中的每一行和UDTF函数输出的每一行举行毗连,天生一张新的虚拟表
  1. -- 如果想学习explode函数怎么使用,需要使用desc进行查询
  2. desc function extended explode;
  3. -- 使用explode将array数据爆炸为单列多行
  4. select explode(`array`(1, 2, 3, 4)) as num;
  5. -- 使用explode将map数据爆炸为多列多行
  6. select explode(`map`('name', '小明', 'age', 18)) as (c1, c2);
  7. -- 夺冠球队案例
  8. -- 1. 建表
  9. create table the_nba_championship
  10. (
  11.         team_name     string,
  12.         champion_year array<string>
  13. ) row format delimited
  14.         fields terminated by ','
  15.         collection items terminated by '|';
  16. -- 2.上传数据
  17. load data local inpath '/root/hive_data/The_NBA_Championship.txt' into table the_nba_championship;
  18. -- 3.查询数据是否上传成功
  19. select *
  20. from the_nba_championship;
  21. -- 4. 将夺冠的年份爆炸为多行
  22. -- 爆炸后,多个年份对应一个队名,不符合结构化数据规则.不能这样书写
  23. -- select team_name, explode(champion_year) from the_nba_championship;
  24. -- 5. 我们可以使用表连接的方式进行合并
  25. select name_list.team_name,
  26.         year_list.year
  27. from the_nba_championship name_list -- 获取所有的球队名称列表
  28.                 join
  29.                 (select explode(champion_year) as year from the_nba_championship) year_list --获取所有的球队夺冠年份列表
  30.                         on array_contains(name_list.champion_year, year_list.year);
  31. -- 6. 上边的方法有点复杂,我们可以使用侧视图,非常简单的完成爆炸函数和原表数据的合并
  32. select *
  33. from the_nba_championship lateral view explode(champion_year) t as year;
  34. -- 侧视图的意义: 就是将UDTF函数在拆分为多行后,还可以与原数据表进行连接,效率更高,写法更简单.
复制代码
9.2、多行转单列


  1. --建表
  2. create table row2col2
  3. (
  4.     col1 string,
  5.     col2 string,
  6.     col3 int
  7. ) row format delimited fields terminated by '\t';
  8. -- 查看数据是否上传成功
  9. select *
  10. from row2col2;
  11. -- 1. 将col1和col2内的相同数据进行合并,此时需要使用group by
  12. select col1,
  13.        col2
  14. from row2col2
  15. group by col1, col2;
  16. -- 2. 获取col3中所有的数据,添加到一个字段值中
  17. select col1,
  18.        col2,
  19.        collect_list(col3) as col3_list -- collect_list()作用就是将多行数据转换为一个array类型数据
  20. from row2col2
  21. group by col1, col2;
  22. -- 3. 使用字符串拼接函数 concat_ws 将数组类型数据拼接为 1-2-3这种格式的数据
  23. -- :Argument 2 of function CONCAT_WS must be "string or array<string>", but "array<int>" was found.
  24. -- select col1,
  25. --        col2,
  26. --        concat_ws('-',collect_list(col3)) as col3_list -- collect_list()作用就是将多行数据转换为一个array类型数据
  27. -- from row2col2
  28. -- group by col1, col2;
  29. desc function extended concat_ws;
  30. desc function extended concat;
  31. -- 4. concat_ws只能使用内部是string类型数据的数组,不能使用内部是int类型数据的数组.
  32. select col1,
  33.        col2,
  34.        concat_ws('-', collect_list(cast(col3 as string))) as col3 -- collect_list()作用就是将多行数据转换为一个array类型数据
  35. from row2col2
  36. group by col1, col2;
复制代码
9.3、单列转多行


  1. --创建表
  2. create table col2row2
  3. (
  4.     col1 string,
  5.     col2 string,
  6.     col3 string
  7. ) row format delimited fields terminated by '\t';
  8. -- 检测数据是否上传成功
  9. select *
  10. from col2row2
  11. limit 1000;
  12. -- 1. 将 col3 中的数据内容,从字符串类型转换为数组类型数据.
  13. select col1,
  14.        col2,
  15.        split(col3, ',') as col3
  16. from col2row2;
  17. -- 2. 将col3中的数组信息炸开,炸开称为多行数据
  18. select explode(split(col3, ','))
  19. from col2row2;
  20. -- 3. 使用侧视图,将UDTF函数的结果和原数据表进行连接
  21. select col1, col2, col_3
  22. from col2row2 lateral view explode(split(col3, ',')) t1 as col_3;
复制代码
9.4、json格式数据处理(要记住json_tuple)


  1. --创建表
  2. create table tb_json_test1
  3. (
  4.     json string
  5. );
  6. select *
  7. from tb_json_test1;
  8. -- 1. 使用get_json_object 解析json
  9. select get_json_object(json, '$.device')     as device,
  10.        get_json_object(json, '$.deviceType') as deviceType,
  11.        get_json_object(json, '$.signal')     as signal,
  12.        get_json_object(json, '$.time')       as `time`
  13. from tb_json_test1;
  14. -- 2. 使用json_tuple 解析json
  15. select json_tuple(json, 'device', 'deviceType', 'signal', 'time') as (device, deviceType, signal, `time`)
  16. from tb_json_test1;
  17. desc function extended json_tuple;
  18. -- 使用json_tuple 配合侧视图进行使用
  19. select json,device, deviceType, signal, `time`
  20. from tb_json_test1 lateral view
  21.     json_tuple(json, 'device', 'deviceType', 'signal', 'time') t_json
  22.     as device, deviceType, signal, `time`;
  23. -- 3.使用jsonserde进行映射
  24. create table tb_json_test2
  25. (
  26.     device string,
  27.     deviceType string,
  28.     signal string,
  29.     `time` string
  30. )
  31. row format serde 'org.apache.hive.hcatalog.data.JsonSerDe';
  32. select * from tb_json_test2;
复制代码
十、Hive 窗口函数[重中之重]

   
  
十一、Hive的数据压缩(节流磁盘空间,提拔io服从)


十二、Hive的数据存储格式




  1. --1、创建表,存储数据格式为TEXTFILE
  2. create table log_text (
  3. track_time string,
  4. url string,
  5. session_id string,
  6. referer string,
  7. ip string,
  8. end_user_id string,
  9. city_id string
  10. )
  11. ROW FORMAT DELIMITED FIELDS TERMINATED BY '\t'
  12. STORED AS TEXTFILE;  --如果不写stored as textfile 默认就是textfile
  13. --加载数据
  14. load data local inpath '/root/hivedata/log.data' into table log_text;
  15. -- 检测数据是否执行成功
  16. select * from log_parquet;
  17. --2、创建表,存储数据格式为ORC
  18. create table log_orc(
  19. track_time string,
  20. url string,
  21. session_id string,
  22. referer string,
  23. ip string,
  24. end_user_id string,
  25. city_id string
  26. )
  27. ROW FORMAT DELIMITED FIELDS TERMINATED BY '\t'
  28. STORED AS orc ;
  29. --向表中插入数据 思考为什么不能使用load命令加载? 因为load是纯复制移动操作 不会调整文件格式。
  30. insert into table log_orc select * from log_text;
  31. --3、创建表,存储数据格式为parquet
  32. create table log_parquet(
  33. track_time string,
  34. url string,
  35. session_id string,
  36. referer string,
  37. ip string,
  38. end_user_id string,
  39. city_id string
  40. )
  41. ROW FORMAT DELIMITED FIELDS TERMINATED BY '\t'
  42. STORED AS PARQUET ;
  43. --向表中插入数据
  44. insert into table log_parquet select * from log_text ;
复制代码
十三、Hive通用调优

13.1、Fetch抓取机制

   原则上,hive操作元数据时不走MR任务, 操作数据时须要走MR任务
  
  1. -- Fatch抓取
  2. select * from student;
  3. -- 没有涉及计算,不需要走mr任务
  4. select * from student where age > 20;
复制代码
13.2、mapreduce本地模式


13.3、join优化




   条件
1) set hive.optimize.bucketmapjoin = true;
​ 2) 两个表的分桶数目必须雷同
​ 2) 两个表的分桶字段必须排序
​ 4) bucket列 == join列 == sort列
​ 5) 必须是应用在map join的场景中
  13.4、group by 数据倾斜优化

   数据倾斜是不可制止的。由于数据已经存在,倾斜是既定事实,我们只能优化盘算方案,不能修改数据

  1. (1)是否在 Map 端进行聚合,默认为 True
  2. set hive.map.aggr = true;
  3. (2)在 Map 端进行聚合操作的条目数目
  4. set hive.groupby.mapaggr.checkinterval = 100000;
  5. (3)有数据倾斜的时候进行负载均衡(默认是 false)
  6. set hive.groupby.skewindata = true;
  7. --Q:在hive中数据倾斜开启负载均衡之后 底层执行机制是什么样?
  8. --step1:启动一个MapReduce程序 将倾斜的数据随机发送到各个reduce中 进行打散
  9.         每个reduce进行聚合都是局部聚合
  10.         
  11. --step2:再启动第二个MapReduce程序 将上一步局部聚合的结果汇总起来进行最终的聚合      
复制代码
13.5、hive中如何调解底层MapReduce中task的个数(并行度)


13.6、其他几个通用调优



免责声明:如果侵犯了您的权益,请联系站长,我们会及时删除侵权内容,谢谢合作!更多信息从访问主页:qidao123.com:ToB企服之家,中国第一个企服评测及商务社交产业平台。




欢迎光临 ToB企服应用市场:ToB评测及商务社交产业平台 (https://dis.qidao123.com/) Powered by Discuz! X3.4