hive 订阅
hive是基于Hadoop的一个数据仓库工具,用来进行数据提取、转化、加载,这是一种可以存储、查询和分析存储在Hadoop中的大规模数据的机制。hive数据仓库工具能将结构化的数据文件映射为一张数据库表,并提供SQL查询功能,能将SQL语句转变成MapReduce任务来执行。Hive的优点是学习成本低,可以通过类似SQL语句实现快速MapReduce统计,使MapReduce变得更加简单,而不必开发专门的MapReduce应用程序。hive十分适合对数据仓库进行统计分析。 [1] 展开全文
hive是基于Hadoop的一个数据仓库工具,用来进行数据提取、转化、加载,这是一种可以存储、查询和分析存储在Hadoop中的大规模数据的机制。hive数据仓库工具能将结构化的数据文件映射为一张数据库表,并提供SQL查询功能,能将SQL语句转变成MapReduce任务来执行。Hive的优点是学习成本低,可以通过类似SQL语句实现快速MapReduce统计,使MapReduce变得更加简单,而不必开发专门的MapReduce应用程序。hive十分适合对数据仓库进行统计分析。 [1]
信息
外文名
hive
兼容性
hadoop生态圈
定    义
在Hadoop上的数据仓库基础构架
依    赖
jdk,hadoop
所属学科
大数据、数据分析
hive简介
hive是基于Hadoop构建的一套数据仓库分析系统,它提供了丰富的SQL查询方式来分析存储在Hadoop分布式文件系统中的数据:可以将结构化的数据文件映射为一张数据库表,并提供完整的SQL查询功能;可以将SQL语句转换为MapReduce任务运行,通过自己的SQL查询分析需要的内容,这套SQL简称Hive SQL,使不熟悉mapreduce的用户可以很方便地利用SQL语言‘查询、汇总和分析数据。而mapreduce开发人员可以把自己写的mapper和reducer作为插件来支持hive做更复杂的数据分析。它与关系型数据库的SQL略有不同,但支持了绝大多数的语句如DDL、DML以及常见的聚合函数、连接查询、条件查询。它还提供了一系列的1:具进行数据提取转化加载,用来存储、查询和分析存储在Hadoop中的大规模数据集,并支持UDF(User-Defined Function)、UDAF(User-Defnes AggregateFunction)和USTF(User-Defined Table-Generating Function),也可以实现对map和reduce函数的定制,为数据操作提供了良好的伸缩性和可扩展性。 [2]  hive不适合用于联机(online)事务处理,也不提供实时查询功能。它最适合应用在基于大量不可变数据的批处理作业。hive的特点包括:可伸缩(在Hadoop的集群上动态添加设备)、可扩展、容错、输入格式的松散耦合。 [2] 
收起全文
精华内容
下载资源
问答
  • hive
    千次阅读
    2022-04-01 17:13:58


    学HIVE上官网 hive官网

    hive简介

    hadoop广义:是大数据生态圈,其中hive是使用SQL完成大数据统计分析的工具
    hadoop狭义:HDFS MR yarn
    hive是Facebook公司开源的工具,用来解决海量的结构化日志的统计问题
    hive是构建在hadoop之上的数据仓库
    HDFS:hive的数据是存放在HDFS(distributed storge),元数据(metadata)存放在对应的底层数据库,并且一般是MySQL
    MR(计算引擎):hive的作业(SQL)是通过hive的框架翻译成MR作业
    这里的计算引擎也可以是Tez,Spark,
    但是不管底层用的什么引擎,对于用户来说是不感知的
    同样的SQL,只需要通过参数切换,就可以实现
    Yarn:hive的作业提交到Yarn上去运行的

    Hadoop开发可以使用单机,但生产上一定是分布式
    hive其实就是一个客户端,没有集群的概念,提交作业到集群的Yarn上去运行(没有感情的提交机器)
    SQL==>Hive==>MR==>Yarn
    生产环境上,哪台机器需要提交hive,就在哪台机器上配置hive,不同机器上的hive是相互独立的

    而Hive的职责:将SQL翻译成底层对应的执行引擎作业

    对于distributed storge(文件存储系统)
    HDFS,AWS S3,各种云 OSS COS
    这些系统,hive都可以对接,只要有对应的jar包
    本地的文件系统(file开头)也可以对接

    metadata
    有统一的元数据管理
    hive中有2个同名的容易搞混的概念
    元数据与源数据
    元数据:描述数据的数据
    源数据:来源系统的数据,HDFS的数据,各个数据库的数据

    例如:
    源数据:HDFS上有一个emp.txt
    KING,5000
    JHON,1000
    CINDY,2800
    这样的数据叫源数据,也就是原始的数据

    元数据:
    table:emp
    ename:string
    sal:int
    seq(分隔符):,
    列的顺序:第一列是ename,第二列是sal
    数据存放位置也是共享的

    所以spark/impala/presto 等等,都是统一使用metadata
    也就是说在hive里建的表,sparkSQL也能使用

    hive官网怎么说?
    那就上官网看看
    官网怎么说?
    那就上官网看
    The Apache Hive ™ data warehouse software facilitates reading, writing, and managing large datasets residing in distributed storage using SQL. Structure can be projected onto data already in storage. A command line tool and JDBC driver are provided to connect users to Hive.

    hive VS RDBMS(关系型数据库)
    分布式:11 均支持
    节点:11 均支持
    成本:廉价 VS 昂贵
    数据量:TB级别,加起来有PB级别甚至更高 VS GB
    事务(开始于insert、update、delete,结束于commit、rollback或ddl语句):均支持
    延时性:高 VS 低
    DML(增删改):0.14版本之后(但是不建议用) VS 支持
    大数据里几乎不用update也不允许用

    Hive适用场景
    批处理/离线处理

    Hive优缺点
    优点:易上手,比MR使用起来简单多了
    缺点:延时性高

    初学者容易问的一些问题:
    Q:hive的执行速度,对比于mysql谁快谁慢?
    A:这个问题其实没法回答,需要看数据量来决定谁快,这个问题就好比再问詹姆斯和C罗谁的成就更高?不是一个领域的东西没法比较

    Q:hive sql和MySQL的sql有什么关系?
    A:虽然他们都叫sql但是除了语法类似之外,没有任何关系

    安装

    hive的安装过程与hadoop较为类似

    1. 下载hive压缩包tar.gz文件

    2. 解压
      tar -zxvf apache-hive-3.1.2-bin-tar-gz -C /home/zhangyuje/app/

    3. 创建软链接
      ln -s apache-hive-3.1.2-bin hive

    4. 查看目录结构
      bin :可执行文件
      conf :配置文件
      lib :hive相关的jar包

    5. 环境变量
      (无所谓放哪里,但是这三个环境变量区别需要去看profile,.bashrc以及.bash_profile)
      export HIVE_HOME=/home/zhangyujie/app/hive export PATH=${HIVE_HOME}/bin:${PATH}

    6. 配置文件
      本身hive-site.xml是没有的
      但是可以复制一分hive-default.xml.template
      作为hive-site.xml(cp)
      同时也需要将其中的配置信息进行修改

    7. 初始化元数据
      schematool -dbType mysql -initSchema
      有可能会报错报错之后注意看日志,可能是权限之类的问题没搞定
      如果没有权限创建初始库,那就手动去创建库

    8. 启动
      进入hive文件夹内bin目录下 ./hive

    9. 创建一个表
      create table test0330(id bigint,name string,sal bigint)
      hive里面用的数据类型很少常用的为BIGINT double string,date都不常用
      放点数据
      insert into test0330 values(1,‘xxx’,10)
      insert into test0330 values(2,‘xxx2’,11)

    10. 连接hive
      CLI(命令界面)
      JDBC(dbeaver)后面会有一些简单的连接过程
      其他的开源框架(HUE,Zeppelin)

    11. 修改配置
      可以在hive-site.xml中修改配置,也可以通过其他办法
      1 hive --hiveconf
      这种方式启动可以跟上需要修改的参数
      比如说hive --hiveconf hive.cli.print.header=false退出在通过hive登陆就
      回去了
      2 进入hive之后可以通过set命令去配置
      set hive.cli.print.header=true;
      我光输入set hive.cli.print.header;可以获取其值
      这里的set相当于get了
      3 生效顺序
      hive-site.xml < hive --hiveconf < set hive.cli.print.header=true
      也就是说在启动的时候如果没有进行hive --hiveconf就采用hive-site.xml
      若启动后进入hive则以在hive里进行配置的为准

    使用dbeaver连接自己的hive

    这里我也是踩了一些坑的,听我慢慢说来

    1. 下载dbeaver
    2. 打开dbeaver->新建连接->选择hadoop/hive
    3. 填写url以及hive表名以及拥有hadoop的linux用户名
      url一般为hive所在机器的ip地址,端口号一般为10000不用修改,如果是本地则url改为localhost。
      需要注意如果为远程机器,请查看端口10000是否开启
    4. 点击编辑连接将hive文件夹里面的hive-jdbc-standlone.jar以及hadoop
      目录下share/hadoop/common/hadoop-common-版本号.jar包加入
    5. 这个时候大概率会遇到权限问题,可能提示拒绝连接,不要慌,这个时候进入hadoop中的core-site.xml文件添加以下内容
    <property>
        <name>hadoop.proxyuser.root.hosts</name>
        <value>*</value>
    </property>
    <property>
        <name>hadoop.proxyuser.root.groups</name>
        <value>*</value>
    </property>
    

    这里的root是你拥有hive以及hadoop的linux用户。

    1. 将各种服务启动起来,包括hadoop和mysql ,
      然后依次启动metastore服务
      hive --service metastore
      用root用户或者有sudo权限的用户使用netstat -nlp |grep 9083查看 9083端口是否被监听。
      然后启动hiveserver2服务
      hive --service hiveserver2
      用上面同样方法查看是否监听10000端口。
      到这里就有人发现了dbeaver里面的端口号为什么是默认10000并且不用修改了
    2. 一般来说到这里dbeaver就能成功连上hive了,hiveserver也会显示ok
      但是我做到这里,却并没有成功,
      然后我去查看hive的日志(也是百度了好久才知道hive日志在哪里)一般来说是/tmp/hive的用户/hive.log文件,
      我查看后发现是hive-site.xml里面配置有问题,由于我的xml文件是直接问别人要的写好的文件,并没有把别人的主机名改成自己的主机名,导致hiveserver2启动了半天没成功,报错一直是找不到主机名。
      修改过后果然一下子就成了
    更多相关内容
  • Hive基础教程 Hive入门

    千次阅读 2021-02-21 10:52:50
    hive是基于Hadoop构建的一套数据仓库分析系统,它提供了丰富的SQL查询方式来分析存储在Hadoop分布式文件系统中的数据:可以将结构化的数据文件映射为一张数据库表,并提供完整的SQL查询功能;可以将SQL语句转换为...

    第1章 Hive基本概念

    1.1 什么是Hive

    1)hive简介
    Hive:由Facebook开源用于解决海量结构化日志的数据统计工具。

    Hive是基于Hadoop的一个数据仓库工具,可以将结构化的数据文件映射为一张表,并提供类sQL查询功能。

    hive是基于Hadoop构建的一套数据仓库分析系统,它提供了丰富的SQL查询方式来分析存储在Hadoop分布式文件系统中的数据:可以将结构化的数据文件映射为一张数据库表,并提供完整的SQL查询功能;可以将SQL语句转换为MapReduce任务运行,通过自己的SQL查询分析需要的内容,这套SQL简称Hive SQL,使不熟悉mapreduce的用户可以很方便地利用SQL语言查询、汇总和分析数据。
    2)Hive本质:将HQL转化为MapReduce程序
    在这里插入图片描述
    (1)Hive 处理的数据存储在 HDFS
    (2)Hive 分析数据底层的实现是 MapReduce
    (3)执行程序运行在 Yarn 上

    1.2 Hive 的优缺点

    1.2.1 优点

    (1)操作接口采用类 SQL 语法,提供快速开发的能力(简单、容易上手)。
    (2)避免了去写 MapReduce,减少开发人员的学习成本。
    (3)Hive 的执行延迟比较高,因此 Hive 常用于数据分析,对实时性要求不高的场合。
    (4)Hive 优势在于处理大数据,对于处理小数据没有优势,因为 Hive 的执行延迟比较
    高。
    (5)Hive 支持用户自定义函数,用户可以根据自己的需求来实现自己的函数。

    1.2.2 缺点

    1 )Hive 的 的 HQL 表达能力有限
    (1)迭代式算法无法表达
    (2)数据挖掘方面不擅长,由于 MapReduce 数据处理流程的限制,效率更高的算法却
    无法实现。

    2 )Hive 的效率比较低
    (1)Hive 自动生成的 MapReduce 作业,通常情况下不够智能化
    (2)Hive 调优比较困难,粒度较粗

    1.3 Hive 架构原理

    在这里插入图片描述
    1 ) 用户接口:Client
    CLI(command-line interface)、JDBC/ODBC(jdbc 访问 hive)、WEBUI(浏览器访问 hive)

    2 ) 元数据:Metastore
    元数据包括:表名、表所属的数据库(默认是 default)、表的拥有者、列/分区字段、
    表的类型(是否是外部表)、表的数据所在目录等;

    默认存储在自带的 derby 数据库中,推荐使用 MySQL 存储 Metastore

    3 )Hadoop
    使用 HDFS 进行存储,使用 MapReduce 进行计算。

    4 ) 驱动器:Driver
    (1)解析器(SQL Parser):将 SQL 字符串转换成抽象语法树 AST,这一步一般都用第
    三方工具库完成,比如 antlr;对 AST 进行语法分析,比如表是否存在、字段是否存在、SQL
    语义是否有误。
    (2)编译器(Physical Plan):将 AST 编译生成逻辑执行计划。
    (3)优化器(Query Optimizer):对逻辑执行计划进行优化。
    (4)执行器(Execution):把逻辑执行计划转换成可以运行的物理计划。对于 Hive 来
    说,就是 MR/Spark。
    在这里插入图片描述
    Hive 通过给用户提供的一系列交互接口,接收到用户的指令(SQL),使用自己的 Driver,
    结合元数据(MetaStore),将这些指令翻译成 MapReduce,提交到 Hadoop 中执行,最后,将执行返回的结果输出到用户交互接口。

    1.4 Hive 和数据库比较

    由于 Hive 采用了类似 SQL 的查询语言 HQL(Hive Query Language),因此很容易将 Hive 理解为数据库。其实从结构上来看,Hive 和数据库除了拥有类似的查询语言,再无类似之处。
    本文将从多个方面来阐述 Hive 和数据库的差异。数据库可以用在 Online 的应用中,但是
    Hive 是为数据仓库而设计的,清楚这一点,有助于从应用角度理解 Hive 的特性。

    1.4.1 查询语言

    由于 SQL 被广泛的应用在数据仓库中,因此,专门针对 Hive 的特性设计了类 SQL 的查
    询语言 HQL。熟悉 SQL 开发的开发者可以很方便的使用 Hive 进行开发。

    1.4.2 数据更新

    由于 Hive 是针对数据仓库应用设计的,而数据仓库的内容是读多写少的。因此,Hive 中不建议对数据的改写,所有的数据都是在加载的时候确定好的。 而数据库中的数据通常是需要经常进行修改的,因此可以使用 INSERT INTO … VALUES 添加数据,使用 UPDATE … SET 修改数据。

    1.4.3 执行延迟

    Hive 在查询数据的时候,由于没有索引,需要扫描整个表,因此延迟较高。另外一个导
    致 Hive 执行延迟高的因素是 MapReduce 框架。由于 MapReduce 本身具有较高的延迟,因此
    在利用 MapReduce 执行 Hive 查询时,也会有较高的延迟。相对的,数据库的执行延迟较低。
    当然,这个低是有条件的,即数据规模较小,当数据规模大到超过数据库的处理能力的时候,
    Hive 的并行计算显然能体现出优势。

    1.4.4 数据规模

    由于 Hive 建立在集群上并可以利用 MapReduce 进行并行计算,因此可以支持很大规模的数据;对应的,数据库可以支持的数据规模较小。

    第2章 Hive安装

    2.1 Hive 安装地址

    1 )Hive 官网地址
    http://hive.apache.org/
    2 ) 文档查看地址
    https://cwiki.apache.org/confluence/display/Hive/GettingStarted
    3 )下载地址
    http://archive.apache.org/dist/hive/
    4 )github 地址
    https://github.com/apache/hive

    2.2 Hive安装部署

    2.2.1 安装Hive

    1 )把 把 apache-hive-3.1.2-bin.tar.gz 上传到 linux 的/opt/software 目录下
    2 ) 解压 apache-hive-3.1.2-bin.tar.gz 到/opt/module/ 目录下面

    [atguigu@hadoop102 software]$ tar -zxvf /opt/software/apache-hive-3.1.2-
    bin.tar.gz -C /opt/module/
    

    3 ) 修改 apache-hive-3.1.2-bin.tar.gz 的名称为 hive

    [atguigu@hadoop102 software]$ mv /opt/module/apache-hive-3.1.2-bin/
    /opt/module/hive
    

    4 ) 修改/etc/profile.d/my_env.sh , 添加环境变量

    [atguigu@hadoop102 software]$ sudo vim /etc/profile.d/my_env.sh
    

    5 ) 添加内容

    #HIVE_HOME
    export HIVE_HOME=/opt/module/hive
    export PATH=$PATH:$HIVE_HOME/bin
    

    6 ) 解决日志 Jar 包冲突

    [atguigu@hadoop102 software]$ mv $HIVE_HOME/lib/log4j-slf4j-impl-
    2.10.0.jar $HIVE_HOME/lib/log4j-slf4j-impl-2.10.0.bak
    

    7 )初始化元数据库

    [atguigu@hadoop102 hive]$ bin/schematool -dbType derby -initSchema
    

    2.2.2 用 启动并使用 Hive

    1 )启动 Hive

    [atguigu@hadoop102 hive]$ bin/hive
    

    2 )使用 Hive

    hive> show databases;
    hive> show tables;
    hive> create table test(id int);
    hive> insert into test values(1);
    hive> select * from test;
    

    3 )在 CRT 窗口 中开启另一个窗口开启 Hive ,在/tmp/atguigu 目录下监控 hive.log 文件

    Caused by: ERROR XSDB6: Another instance of Derby may have already booted the database /opt/module/hive/metastore_db.
    at
    org.apache.derby.iapi.error.StandardException.newException(Unknown Source)
    at
    org.apache.derby.iapi.error.StandardException.newException(Unknown Source)
    at
    org.apache.derby.impl.store.raw.data.BaseDataFileFactory.privGetJBMSLockOnDB(Unknown Source)
    at
    org.apache.derby.impl.store.raw.data.BaseDataFileFactory.run(Unknown Source)
    ...
    

    原因在于 Hive 默认使用的元数据库为 derby,开启 Hive 之后就会占用元数据库,且不与
    其他客户端共享数据,所以我们需要将 Hive 的元数据地址改为 MySQL。

    2.3 MySQL安装

    5 ) 删除/etc/my.cnf 文件中 datadir 指向的目录下的所有内容, 如果有内容的情况下:
    查看 datadir 的值:
    [mysqld]
    datadir=/var/lib/mysql
    
    删除/var/lib/mysql 目录下的所有内容:
    [atguigu @hadoop102 mysql]# cd /var/lib/mysql
    [atguigu @hadoop102 mysql]# sudo rm -rf ./* //注意执行命令的位置
    
    6 ) 初始化 数据库
    [atguigu @hadoop102 opt]$ sudo mysqld --initialize --user=mysql
    
    7 ) 查看临时生成的 root 用户的密码
    [atguigu @hadoop102 opt]$ sudo cat /var/log/mysqld.log
    A temporary password is generated for root@localhost:xxxxxxx
    
    8 ) 启动 MySQL 服务
    [atguigu @hadoop102 opt]$ sudo systemctl start mysqld
    9 ) 登录 MySQL 数据库
    [atguigu @hadoop102 opt]$ mysql -uroot -p
    Enter password: 输入临时生成的密码
    
    10 ) 必须先 修改 root 用户的密码, 否则 执行其他的操作 会报错
    mysql> set password = password("新密码");
    11 ) 修改 mysql 库下的 user 表中的 root 用户允许任意 ip 连接
    mysql> update mysql.user set host='%' where user='root';
    mysql> flush privileges;
    

    2.4 Hive 到 元数据配置到 MySQL

    2.4.1 拷贝 驱动

    将 MySQL 的 JDBC 驱动拷贝到 Hive 的 lib 目录下
    [atguigu@hadoop102 software]$ cp /opt/software/mysql-connector-java-
    5.1.37.jar $HIVE_HOME/lib
    

    2.4.2 配置 Metastore到MySQL

    1 ) 在$HIVE_HOME/conf 目录下新建 hive-site.xml 文件

    [atguigu@hadoop102 software]$ vim $HIVE_HOME/conf/hive-site.xml
    添加如下内容
    
    <?xml version="1.0"?>
    <?xml-stylesheet type="text/xsl" href="configuration.xsl"?>
    <configuration>
    <!-- jdbc 连接的 URL -->
    <property>
    <name>javax.jdo.option.ConnectionURL</name>
    <value>jdbc:mysql://hadoop102:3306/metastore?useSSL=false</value>
    </property>
    <!-- jdbc 连接的 Driver-->
    <property>
    <name>javax.jdo.option.ConnectionDriverName</name>
    <value>com.mysql.jdbc.Driver</value>
    </property>
    <!-- jdbc 连接的 username-->
    <property>
    <name>javax.jdo.option.ConnectionUserName</name>
    <value>root</value>
    </property>
    <!-- jdbc 连接的 password -->
    <property>
    <name>javax.jdo.option.ConnectionPassword</name>
    <value>000000</value>
    </property>
    <!-- Hive 元数据存储版本的验证 -->
    <property>
    <name>hive.metastore.schema.verification</name>
    <value>false</value>
    </property>
    <!--元数据存储授权-->
    <property>
    <name>hive.metastore.event.db.notification.api.auth</name>
    <value>false</value>
    </property>
    <!-- Hive 默认在 HDFS 的工作目录 -->
    <property>
    <name>hive.metastore.warehouse.dir</name>
    <value>/user/hive/warehouse</value>
    </property>
    </configuration>
    

    2 ) 登陆 MySQL

    [atguigu@hadoop102 software]$ mysql -uroot -p000000
    

    3 ) 新建 Hive 元数据库

    mysql> create database metastore;
    mysql> quit;
    

    4 ) 初始化 Hive 元数据库

    [atguigu@hadoop102 software]$ schematool -initSchema -dbType mysql -verbose
    

    2.4.3 再次启动 Hive

    1 )启动 Hive

    [atguigu@hadoop102 hive]$ bin/hive
    

    2 )使用 Hive

    hive> show databases;
    hive> show tables;
    hive> create table test (id int);
    hive> insert into test values(1);
    hive> select * from test;
    

    3 )在 CRT 窗口 中开启另一个窗口开启 Hive

    hive> show databases;
    hive> show tables;
    hive> select * from aa;
    

    2.5 使用元数据服务的方式访问 Hive

    1 )在 在 hive-site.xml 文件中添加如下配置信息

    <!-- 指定存储元数据要连接的地址 -->
    <property>
    <name>hive.metastore.uris</name>
    <value>thrift://hadoop102:9083</value>
    </property>
    

    2 ) 启动 metastore

    [atguigu@hadoop202 hive]$ hive --service metastore
    2020-04-24 16:58:08: Starting Hive Metastore Server
    注意: 启动后窗口不能再操作,需打开一个新的 shell 窗口做别的操作
    

    3 ) 启动 hive

    [atguigu@hadoop202 hive]$ bin/hive
    

    2.6 使用JDBC方式访问Hive

    1 )在hive-site.xml 文件中添加如下配置信息

    <!-- 指定 hiveserver2 连接的 host -->
    <property>
    	<name>hive.server2.thrift.bind.host</name>
    	<value>hadoop102</value>
    </property>
    
    <!-- 指定 hiveserver2 连接的端口号 -->
    <property>
    	<name>hive.server2.thrift.port</name>
    	<value>10000</value>
    </property>
    

    2 )启动 hiveserver2

    [atguigu@hadoop102 hive]$ bin/hive --service hiveserver2
    

    3 ) 启动 beeline 客户端 ( 需要多等待一会 )

    [atguigu@hadoop102 hive]$ bin/beeline -u jdbc:hive2://hadoop102:10000 -n atguigu
    

    4 ) 看到如下界面

    Connecting to jdbc:hive2://hadoop102:10000
    Connected to: Apache Hive (version 3.1.2)
    Driver: Hive JDBC (version 3.1.2)
    Transaction isolation: TRANSACTION_REPEATABLE_READ
    Beeline version 3.1.2 by Apache Hive
    0: jdbc:hive2://hadoop102:10000>
    

    5 ) 编写 hive 服务启动脚本 (了解)
    (1) 前台启动的方式导致需要打开多个 shell 窗口,可以使用如下方式后台方式启动

    nohup: 放在命令开头,表示不挂起,也就是关闭终端进程也继续保持运行状态
    /dev/null:是 Linux 文件系统中的一个文件,被称为黑洞,所有写入改文件的内容都会被自动丢弃
    2>&1 : 表示将错误重定向到标准输出上
    &: 放在命令结尾,表示后台运行
    
    一般会组合使用: nohup [xxx 命令操作]> file 2>&1 &,表示将 xxx 命令运行的结果输出到 file 中,并保持命令启动的进程在后台运行。
    
    [atguigu@hadoop202 hive]$ nohup hive --service metastore 2>&1 &
    [atguigu@hadoop202 hive]$ nohup hive --service hiveserver2 2>&1 &
    

    (2) 为了方便使用,可以直接编写脚本来管理服务的启动和关闭

    [atguigu@hadoop102 hive]$ vim $HIVE_HOME/bin/hiveservices.sh
    
    #!/bin/bash
    HIVE_LOG_DIR=$HIVE_HOME/logs
    if [ ! -d $HIVE_LOG_DIR ]
    then
    mkdir -p $HIVE_LOG_DIR
    fi
    #检查进程是否运行正常,参数 1 为进程名,参数 2 为进程端口
    function check_process(){
    	pid=$(ps -ef 2>/dev/null | grep -v grep | grep -i $1 | awk '{print $2}')
    	ppid=$(netstat -nltp 2>/dev/null | grep $2 | awk '{print $7}' | cut -d '/' -f 1)
    	echo $pid
    	[[ "$pid" =~ "$ppid" ]] && [ "$ppid" ] && return 0 || return 1  #左边字符串是否匹配右边 =~
    # =~:正则匹配,用来判断其左侧的参数是否符合右边的要求,如果匹配就输出1,不匹配就输出0
    }
    
    function hive_start()
    {
    	metapid=$(check_process HiveMetastore 9083)
    	cmd="nohup hive --service metastore >$HIVE_LOG_DIR/metastore.log 2>&1
    	&"
    	[ -z "$metapid" ] && eval $cmd || echo "Metastroe 服务已启动"
    	server2pid=$(check_process HiveServer2 10000)
    	cmd="nohup hiveserver2 >$HIVE_LOG_DIR/hiveServer2.log 2>&1 &"
    	[ -z "$server2pid" ] && eval $cmd || echo "HiveServer2 服务已启动"
    }
    
    function hive_stop()
    {
    	metapid=$(check_process HiveMetastore 9083)
    	[ "$metapid" ] && kill $metapid || echo "Metastore 服务未启动"
    	server2pid=$(check_process HiveServer2 10000)
    	[ "$server2pid" ] && kill $server2pid || echo "HiveServer2 服务未启动"
    }
    case $1 in
    "start")
    	hive_start
    	;;
    "stop")
    	hive_stop
    	;;
    "restart")
    	hive_stop
    	sleep 2
    	hive_start
    	;;
    "status")
    	check_process HiveMetastore 9083 >/dev/null && echo "Metastore 服务运行
    	正常" || echo "Metastore 服务运行异常"
    	check_process HiveServer2 10000 >/dev/null && echo "HiveServer2 服务运
    	行正常" || echo "HiveServer2 服务运行异常"
    	;;
    *)
    	echo Invalid Args!
    	echo 'Usage: '$(basename $0)' start|stop|restart|status'
    	;;
    esac
    

    3 ) 添加执行权限

    [atguigu@hadoop102 hive]$ chmod +x $HIVE_HOME/bin/hiveservices.sh
    

    4 ) 启动 Hive 后台服务

    [atguigu@hadoop102 hive]$ hiveservices.sh start
    

    2.7 Hive常用交互命令

    [atguigu@hadoop102 hive]$ bin/hive -help
    usage: hive
    -d,--define <key=value> Variable subsitution to apply to hive
    commands. e.g. -d A=B or --define A=B
    --database <databasename> Specify the database to use
    -e <quoted-query-string> SQL from command line
    -f <filename> SQL from files
    -H,--help Print help information
    --hiveconf <property=value> Use value for given property
    --hivevar <key=value> Variable subsitution to apply to hive
    commands. e.g. --hivevar A=B
    -i <filename> Initialization SQL file
    -S,--silent Silent mode in interactive shell
    -v,--verbose Verbose mode (echo executed SQL to the
    console)
    

    1 ) “-e ”不进入 hive 的交互窗口执行 sql 语句

    [atguigu@hadoop102 hive]$ bin/hive -e "select id from student;"
    

    2 ) “-f ”执行脚本中 sql 语句
    (1)在/opt/module/hive/下创建 datas 目录并在 datas 目录下创建 hivef.sql 文件

    [atguigu@hadoop102 datas]$ touch hivef.sql
    

    (2)文件中写入正确的 sql 语句

    select * from student;
    

    (3)执行文件中的 sql 语句

    [atguigu@hadoop102 hive]$ bin/hive -f /opt/module/hive/datas/hivef.sql
    

    (4)执行文件中的 sql 语句并将结果写入文件中

    [atguigu@hadoop102 hive]$ bin/hive -f /opt/module/hive/datas/hivef.sql >
    /opt/module/datas/hive_result.txt
    

    2.8 Hive其他命令操作

    1)退出 hive 窗口:
    hive(default)>exit;
    hive(default)>quit;
    
    2)hive cli 命令窗口中如何查看 hdfs 文件系统
    hive(default)>dfs -ls /;
    
    3)查看在 hive 中输入的所有历史命令
    (1)进入到当前用户的根目录 /root 或/home/atguigu
    (2)查看. hivehistory 文件
    [atguig2u@hadoop102 ~]$ cat .hivehistory
    

    2.9 Hive常见属性配置

    2.9.1 Hive 运行日志信息配置

    1)Hive 的 的 log 默认存放在/tmp/atguigu/hive.log 目录下(当前用户名下)
    2)修改 hive 的 的 log 存放日志到/opt/module/hive/logs
    (1)修改/opt/module/hive/conf/hive-log4j2.properties.template 文件名称为

    hive-log4j2.properties
    [atguigu@hadoop102 conf]$ pwd
    /opt/module/hive/conf
    [atguigu@hadoop102 conf]$ mv hive-log4j2.properties.template hive-log4j2.properties
    

    (2)在 hive-log4j2.properties 文件中修改 log 存放位置

    hive.log.dir=/opt/module/hive/logs
    

    2.9.2 打印当前库和表头

    在 hive-site.xml 中加入如下两个配置:

    <property>
    	<name>hive.cli.print.header</name>
    	<value>true</value>
    </property>
    <property>
    	<name>hive.cli.print.current.db</name>
    	<value>true</value>
    </property>
    

    2.9.3 参数配置方式

    1 ) 查看当前所有的配置信息
    hive>set;
    2 ) 参数的配置三种方式
    (1)配置文件方式
    默认配置文件:hive-default.xml
    用户自定义配置文件:hive-site.xml
    注意:用户自定义配置会覆盖默认配置。另外,Hive 也会读入 Hadoop 的配置,因为 Hive
    是作为 Hadoop 的客户端启动的,Hive 的配置会覆盖 Hadoop 的配置。配置文件的设定对本
    机启动的所有 Hive 进程都有效。
    (2)命令行参数方式
    启动 Hive 时,可以在命令行添加-hiveconf param=value 来设定参数。
    例如:

    [atguigu@hadoop103 hive]$ bin/hive -hiveconf mapred.reduce.tasks=10;
    
    注意:仅对本次 hive 启动有效
    

    查看参数设置:

    hive (default)> set mapred.reduce.tasks;
    

    (3)参数声明方式
    可以在 HQL 中使用 SET 关键字设定参数
    例如:

    hive (default)> set mapred.reduce.tasks=100;
    注意:仅对本次 hive 启动有效。
    

    查看参数设置

    hive (default)> set mapred.reduce.tasks;
    

    上述三种设定方式的优先级依次递增。即配置文件<命令行参数<参数声明。注意某些系
    统级的参数,例如 log4j 相关的设定,必须用前两种方式设定,因为那些参数的读取在会话
    建立以前已经完成了。

    第3章 Hive数据类型

    3.1 基本数据类型

    在这里插入图片描述
    对于 Hive 的 String 类型相当于数据库的 varchar 类型,该类型是一个可变的字符串,不
    过它不能声明其中最多能存储多少个字符,理论上它可以存储 2GB 的字符数。

    3.2 集合数据类型

    在这里插入图片描述
    Hive 有三种复杂数据类型 ARRAY、MAP 和 STRUCT。ARRAY 和 MAP 与 Java 中的 Array和 Map 类似,而 STRUCT 与 C 语言中的 Struct 类似,它封装了一个命名字段集合,复杂数据类型允许任意层次的嵌套。

    展开全文
  • Hive

    万次阅读 2019-11-20 15:01:13
    Hive基本概念 ​ 是一个基于hadoop的数据仓库工具,可以将结构化数据映射成一张数据表,并提供类SQL的查询功能。 Hive的意义是什么 ​ 背景:hadoop是个好东西,但是学习难度大,成本高,坡度陡。 ​ 意义(目的)...

    Hive基本概念

    ​ 是一个基于hadoop的数据仓库工具,可以将结构化数据映射成一张数据表,并提供类SQL的查询功能。

    Hive的意义是什么

    ​ 背景:hadoop是个好东西,但是学习难度大,成本高,坡度陡。

    ​ 意义(目的):降低程序员使用hadoop的难度。降低学习成本。

    Hive可以对数据进行存储与计算

    ​ 存储使用HDFS存储

    ​ 计算使用MapReduce进行计算。

    Hive的特性

    ​ 1、扩展性 : Hive的扩展性与集群的扩展性相同

    ​ 2、延展性:Hive支持用户自定义函数,编写符合自己业务需求的函数。

    ​ 3、容错性:节点出现问题(宕机/断电)SQL仍可完成执行。

    Hive缺点

    ​ 每次的执行开销较大,任务运行时间较长,延时较高。

    Hive的内部组成架构

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Ww0s6L5U-1574233245912)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\1574126259456.png)]

    元数据:描述数据的数据(属性)

    ​ 表名称、字段名,字段的数据类型。

    内部执行流程

    ​ 解释器 -> 编译器 -> 优化器 -> 执行器

    数据格式:

    Hive中没有定义专门的数据格式

    数据格式部分自定义:

    ​ 列分隔符(通常为空格、”\t”、”\x001″)

    ​ 行分隔符(”\n”)

    ​ 读取文件数据的方法(Hive 中默认有三个文件格式 TextFile,SequenceFile 以及 RCFile)。

    Hive在加载数据的过程就是拷贝数据的过程,不需要特定的转化。不会对数据本身进行任何修改,甚至不会对数据进行扫描。

    Hive 中不支持对数据的改写和添加(对文本内数据的添加),

    Hive 在加载数据的过程中不会对数据中的某些 Key 建立索引。所以Hive不适合在线数据查询(要求相应速度快)。

    总结:hive具有sql数据库的外表,但应用场景完全不同,hive只适合用来做批量数据统计分析。

    hive支持的数据格式

    ​ 可支持Text,

    ​ SequenceFile,

    ​ ParquetFile,

    ​ ORC格式

    ​ RCFILE等

    Hive元数据

    ​ DB、数据库

    ​ Table,内部表

    ​ External Table,外部表

    ​ Partition,分区

    ​ Bucket,分桶

    Hive安装部署

    ​ 1、derby版hive直接使用

    ​ 每个节点自己维护自己的元数据库(derby),导致多个节点之间元数据不共享。

    ​ 2、mysql共享hive元数据

    ​ 2.1安装mysql

    ​ mysq不推荐使用RPM安装,建议使用yum进行安装

    ​ yum install -y mysql mysql-server mysql-devel

    ​ /etc/init.d/mysqld start

    ​ 配置远程连接(root 只用123456密码)

    ​ grant all privileges on . to ‘root’@’%’ identified by ‘123456’ with grant option;

    ​ 配置mysql用户 root 密码是123456

    ​ update user set password=password(‘123456’) where user=‘root’;

    ​ 2.2 安装HIve

    ​ 现在第一个节点解压hive的安装包。

    ​ 在解压后的目录conf中修改配置文件

    ​ hive-env.sh

    ​ 配置HADOOP_HOME

    ​ 配置HIVE_CONF_DIR

    ​ hive-site.xml

    ​ 添加连接Mysql的配置

    ​ 将解压后的文件夹拷贝到其他节点

    ​ 配置环境变量

    ​ 将mysql-connector-java-5.1.38.jar 上传到HIVE的lib目录下。

    Hive的访问方式

    ​ 1、在Hive客户端,配置hive到环境变量的前提下,在节点的任意位置 直接数据hive + 回车

    ​ [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1BmryL2V-1574233245913)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\1574208461234.png)]

    ​ 2、

    ​ 启动hiveserver2 服务

    ​ hive --service hiveserver2

    ​ 进行连接

    ​ 进入beelin的shell窗口

    ​ 连接hiveserver2服务

    ​ !connect jdbc:hive2://node01:10000

    ​ 输入root 和密码 123456

    ​ 0: jdbc:hive2://node01:10000>
    ​ 0: jdbc:hive2://node01:10000>

    ​ 0: jdbc:hive2://node01:10000> show databases;

    ​ ±---------------±-+
    ​ | database_name |
    ​ ±---------------±-+
    ​ | default |
    ​ | myhive |
    ​ ±---------------±-+

    Hive传选项

    ​ hive -e ‘操作命令’

    ​ hive -e ‘show databases;’

    ​ hive -f 文件名(文件内是操作命令)

    ​ hive -f test.sql

    数据库的基本操作

    ​ 1、数据库的增删改查

    ​ 增 : create database [ if not exists ] myhive ;

    ​ 删 : drop database myhive ; (数据库内没有表可以删除,有表不能删除)

    ​ 改 :数据库不允许修改

    ​ 查 :show databases;

    ​ 查看详细信息:

    ​ desc database myhive2;

    ​ desc database extended myhive2;

    ​ 数据库的切换:

    ​ use myhive(数据库名);

    hive的数据库、表、分区在HDFS的表现形式是文件夹

    数据库的默认路径:/user/hive/warehouse

    ​ 自定义hive数据库的路径:create database myhive2 location ‘/myhive2’;

    数据表的基本操作(增删改查)

    ​ 创建基本数据表(内部表):

    create table tableName(字段名称 字段类型,字段名称 字段类型)

    ​ create table tableName(字段名称 字段类型,字段名称 字段类型)

    ​ ROW FORMAT DELIMITED IELDS TERMINATED BY char (char分隔符)

    ​ 指定数据中字段与字段的分隔符 ‘\t’ 或 ‘,’ 或 ‘|’ 或其他

    ​ 创建外部数据表:

    create EXTERNAL table tableName(字段名称 字段类型,字段名称 字段类型)

    ​ 建外部表需要指定数据的存储路径。通过LOCATION进行指定。

    内部表与外部表的区别:

    ​ 在删除内部表时:内部表删除将表的元数据和数据同时删除。

    ​ 在删除外部表时:外部表的元数据被删除,数据本身不删除。

    删除表

    ​ drop table tablename;

    修改表

    ​ alter tablename ***

    查询表

    ​ show tables;

    ​ desc tablename;

    Hive的数据类型

    ​ 基本数据类型

    ​ INT BIGINT FLOAT DOUBLE DEICIMAL STRING VARCHAR CHAR
    ​ BINARY TIMESTAMP DATE INTERVAL ARRAY

    ​ 复杂数据类型

    ​ MAP STRUCT UNION

    create table stu3 as select * from stu2; 复制数据复试表结构

    create table stu4 like stu2; 不复制数据复试表结构。

    加载数据

    ​ 从linux中加载数据到hive

    ​ load data local inpath ‘数据路径’ into table 表名;

    ​ 从hdfs中加载数据到hive,并覆盖

    ​ load data inpath ‘数据路径’ overwrite into table 表名;

    外部表

    ​ create external table techer (t_id string,t_name string) row format delimited fields terminated by ‘\t’;

    ​ 加载数据

    ​ load data local inpath ‘/export/servers/hivedatas/techer .csv’ into table techer ;

    ​ 在hdfs查看表中的数据

    ​ hadoop fs -ls /user/hive/warehouse/myhive.db/techer

    ​ 在hive中查询

    ​ select * from techer

    ​ 删除数据表techer

    ​ drop table techer;

    ​ 再次查看

    ​ hadoop fs -ls /user/hive/warehouse/myhive.db/techer(数据依然存在)

    内部表

    ​ create table student(t_id string,t_name string) row format delimited fields terminated by ‘\t’;

    ​ 加载数据

    ​ load data local inpath ‘/export/servers/hivedatas/student .csv’ into table student;

    ​ 在hdfs查看表中的数据

    ​ hadoop fs -ls /user/hive/warehouse/myhive.db/student

    ​ 在hive中查询

    ​ select * from student

    ​ 删除数据表techer

    ​ drop table student;

    ​ 再次查看

    ​ hadoop fs -ls /user/hive/warehouse/myhive.db/student(数据不存在)

    分区表

    ​ 企业常见的分区规则:按天进行分区(一天一个分区)

    ​ 创建分区表的语句

    ​ create table score(s_id string,c_id string,s_score int) partitioned by (month string) row format delimited fieldsterminated by ‘\t’;

    ​ create table score2 (s_id string,c_id string,s_score int) partitioned by (year string,month string,day string) row formatdelimited fields terminated by ‘\t’;

    ​ 数据加载

    load data local inpath ‘/opt/hive/score.csv’ into table score partition (month=‘201806’);

    load data local inpath ‘/opt/hive/score.csv’ into table score2 partition(year=‘2018’,month=‘06’,day=‘02’);

    特别强调:

    分区字段绝对不能出现在数据表以有的字段中。

    ​ 作用:

    ​ 将数据按区域划分开,查询时不用扫描无关的数据,加快查询速度。

    分桶表

    ​ 是在已有的表结构之上新添加了特殊的结构

    ​ 开启hive的桶表功能

    set hive.enforce.bucketing=true;

    ​ 设置桶(reduce)的个数

    set mapreduce.job.reduces=3;

    ​ 建分桶表

    ​ create table course (c_id string,c_name string,t_id string) clustered by(c_id) into 3 buckets row format delimited fields terminated by ‘\t’;

    ​ 创建基本表

    ​ create table course_common (c_id string,c_name string,t_id string) row format delimited fields terminated by ‘\t’;

    ​ 基本表添加数据

    ​ load data local inpath ‘/export/servers/hivedatas/course.csv’ into table course_common;

    ​ 在基本表中查询数据插入到分桶表

    insert overwrite table course select * from course_common cluster by(c_id);

    ​ 确认分桶内的数据

    ​ [root@node01 hive]# hadoop fs -cat /user/hive/warehouse/course/000000_0
    ​ 03 英语 03
    ​ [root@node01 hive]# hadoop fs -cat /user/hive/warehouse/course/000001_0
    ​ 01 语文 02
    ​ [root@node01 hive]# hadoop fs -cat /user/hive/warehouse/course/000002_0
    ​ 02 数学 01

    特别强调:

    分桶字段必须是表中的字段。

    分桶逻辑:

    对分桶字段求哈希值,用哈希值与分桶的数量取余,余几,这个数据就放在那个桶内。

    展开全文
  • jdbc连接hive数据库的驱动jar包

    热门讨论 2016-09-19 11:21:04
    jdbc连接hive数据库的jar包.整理可用合集.
  • Hive 核心原理(hive-3.1.2)

    千次阅读 多人点赞 2020-08-29 19:40:13
    全面分析与传统数据库在设计理念、基本使用等方面的相同点和不同点。hive有这一篇差不多就够了

    一、Hive 概述

    1.1 Hive 是什么

    • 由Facebook开源用于解决海量结构化日志的数据统计
    • 基于Hadoop的一个数据仓库工具,可以将结构化的数据文件映射成一张表,并且提供类SQL的查询功能
    • Hive仅仅是一个工具,本身不存储数据只提供一种管理方式,同时也不涉及分布式概念,就是个软件而已
    • Hive本质就是MapReduce,将类SQL(HQL)转换成MapReduce程序

    1.1.1 HQL转换MR流程

    在这里插入图片描述

    解释:

    1. Hive处理的数据存储在HDFS
    2. Hive分析数据底层默认实现是MapReduce[可以修改为spark]
    Hive-on-MR is deprecated in Hive 2 and may not be available in the future versions. Consider using a different execution engine (i.e. spark, tez) or using Hive 1.X releases.
    
    1. 执行的程序运行在yarn上
    2. Hive相当于Hadoop的一个客户端
    3. Hive不是分布式

    1.2 Hive 优缺点

    1.2.1 优点

    1. 操作接口采用类SQL语法,提供快速开发的能力(简单、易上手)
    2. 避免去写MR,减少开发人员学习成本
    3. Hive的延迟比较高(因为MR延迟高),因此Hive常用于数据分析
    4. Hive优势在于处理大数据(数据量少真不如MySQL等)
    5. Hive支持用户自定义函数,可以根据自己的去求实现自己的函数

    1.2.2 缺点

    1. Hive的HQL表达能力有限(MR决定的)
      1. 迭代算法无法表达
      2. 不适用于数据挖掘
    2. Hive的效率比较低
      1. Hive自动生成的MR作业,通常情况不够智能
      2. Hive调优难(只能对资源,SQL层面调优,无法深入作业底层逻辑)

    1.3 Hive 架构原理

    在这里插入图片描述

    1. 用户接口:Client

      CLI(hive shell)、JDBC/ODBC(java访问hive)、WEBUI(浏览器访问hive)

    2. 元数据:Metastore

      包括表名、表所属的数据库、表的拥有者、列/分区字段、表的类型、表数据所在的目录等(自带个derby数据库,推荐配置到MySQL)

    3. 底层存储:HDFS

      使用HDFS进行存储,使用MapReduce计算

    4. 驱动器:Driver

      1. 解析器(SQL Parser):将SQL字符串转换成抽象语法树AST,并对语法树进行语法分析,如:SQL语法、表/字符是否存在
      2. 编译期(Physical Plan):将AST编译生成逻辑执行计划
      3. 优化器(Query Optimizer):对逻辑执行计划进行优化
      4. 执行器(Execution):把逻辑执行计算转换成运行的物理计划,即MR/Spark
        在这里插入图片描述

    Hive通过给用户提供的一系列交互接口,接受到用户编写的SQL,使用自己的Driver结合MetaStore,将SQL指令翻译成MapReduce提交到Hadoop中执行,将执行结果输出到用户交互接口。

    1.4 Hive 和传统数据库比较

    Hive除了提供类似SQL语法外和传统数据库没有任何相似之处,Hive是站在数据仓库出发点而设计的。

    1.4.1 数据存储位置

    Hive是建立在Hadoop之上,所有的Hive数据都是存储在HDFS上;传统数据库将数据保存在本地文件系统中;因此Hive能够处理更大更多的数据

    1.4.2 数据更新

    Hive是针对数据仓库应用设计,因此数据一次写入多次读出,即Hive中不建议对数据进行改写操作,所有数据都是在加载的时候确定好;对于数据库通常需要进行频繁的增删查改

    1.4.3 索引

    Hive在加载数据过程不会对数据进行任何处理,因为数据量庞大建立索引并不划算,因此Hive访问数据中满足特定值需要暴力扫描真个数据,因此访问延迟高。由于MapReduce的引入,Hive可以并行访问数据,即便没有索引也可用于大数据量的访问;传统数据库通常针对一个或多个列建立索引,因此在访问数据是延迟低效率高,即Hive不适合实时数据分析

    1.4.4 执行

    Hive 的执行引擎为MR/Spark,传统数据库都有自己的执行引擎

    1.4.5 可拓展性

    由于Hadoop的高拓展性,因此Hive也具备很强的拓展性;传统数据库的拓展会受到一定的限制

    1.4.6 数据规模

    Hive可以利用MapReduce进行大规模数据的并行计算;传统数据库支持的数据规模较小

    二、Hive 初步

    2.1 Hive 安装

    将元数据配置到MySQL中需要初始化,初始化命令(其余步骤可自行百度):

    schematool -dbType mysql -initSchema
    

    2.2 Hive 基本操作

    1. 启动hive

      [root@master hive-3.2.1]# hive
      
    2. 查看数据库

      hive (hive)> show databases;
      OK
      database_name
      default
      hive
      Time taken: 0.02 seconds, Fetched: 2 row(s)
      

      hive自带一个default数据库,默认也是进这个数据库

    3. 切换数据库

      hive (hive)> use hive;
      OK
      Time taken: 0.031 seconds
      
    4. 创建表

      hive (hive)> create table if not exists tbl_1(id int,name string);
      OK
      Time taken: 0.628 seconds
      

      和MySQL语法基本一致,只是Hive的数据类型和Java类似

    5. 查看表结构

      hive (hive)> desc tbl_1;
      OK
      col_name        data_type       comment
      id                      int
      name                    string
      Time taken: 0.084 seconds, Fetched: 2 row(s)
      -------------------- 分隔符 -------------------
      # 查看表的详细信息
      hive (hive)> desc formatted tbl_1;
      OK
      col_name        data_type       comment
      # col_name              data_type               comment
      id                      int
      name                    string
      
      # Detailed Table Information
      Database:               hive
      OwnerType:              USER
      Owner:                  root
      CreateTime:             Wed Aug 26 19:55:58 CST 2020
      LastAccessTime:         UNKNOWN
      Retention:              0
      Location:               hdfs://master:9000/user/hive/warehouse/hive.db/tbl_1
      Table Type:             MANAGED_TABLE
      Table Parameters:
              COLUMN_STATS_ACCURATE   {\"BASIC_STATS\":\"true\",\"COLUMN_STATS\":{\"id\":\"true\",\"name\":\"true\"}}
              bucketing_version       2
              numFiles                0
              numRows                 0
              rawDataSize             0
              totalSize               0
              transient_lastDdlTime   1598442958
      
      # Storage Information
      SerDe Library:          org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe
      InputFormat:            org.apache.hadoop.mapred.TextInputFormat
      OutputFormat:           org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat
      Compressed:             No
      Num Buckets:            -1
      Bucket Columns:         []
      Sort Columns:           []
      Storage Desc Params:
              serialization.format    1
      Time taken: 0.154 seconds, Fetched: 32 row(s)
      
    6. 插入数据(不要用,不要用,不要用)

      hive (hive)> insert into tbl_1 values(1,'zhangsan');
      ...
      ...
      ...
      Time taken: 84.754 seconds
      

      谁用谁知道

    7. 查询数据

      hive (hive)> select * from tbl_1;
      OK
      tbl_1.id        tbl_1.name
      1       zhangsan
      Time taken: 0.214 seconds, Fetched: 1 row(s)
      
    8. 退出hive

      hive (hive)> quit;
      
    9. 执行hdfs shell

      hive (hive)> dfs -ls /;
      Found 3 items
      drwxr-xr-x   - root supergroup          0 2020-07-21 15:57 /HBase
      drwx-wx-wx   - root supergroup          0 2020-07-21 18:27 /tmp
      drwxrwxrwx   - root supergroup          0 2020-07-21 18:00 /user
      
    10. 执行linux shell

      hive (hive)> !pwd;
      /usr/local/soft/hive-3.2.1
      

    2.3 Hive 常规操作

    hive (hive)> insert into tbl_1 values(1,'zhangsan');
    ...
    ...
    ...
    Time taken: 84.754 seconds
    

    插入一条数据84秒,显然不现实…为此Hive插入数据将采用最暴力最直接的方式,只需要将数据文件放到hdfs制定的路径即可。但也不是什么数据都可以,需要在创建表时指定分隔符。

    hive (hive)> create table if not exists tbl_2(id int,name string)
               > row format delimited fields terminated by '\t';
    OK
    Time taken: 0.118 seconds
    

    准备数据

    [root@master data]# cat student.txt
    1       zhangsan
    2       lisi
    3       wangwu
    4       zhaoliu
    5       tianqi
    [root@master data]# pwd
    /usr/local/soft/hive-3.2.1/data
    

    2.3.1 hive 插入数据一

    加载本地数据到hive

    hive (hive)> load data local inpath '/usr/local/soft/hive-3.2.1/data/student.txt' into table tbl_2;
    Loading data to table hive.tbl_2
    OK
    Time taken: 0.311 seconds
    
    hive (hive)> select * from tbl_2;
    OK
    tbl_2.id        tbl_2.name
    1       zhangsan
    2       lisi
    3       wangwu
    4       zhaoliu
    5       tianqi
    Time taken: 0.192 seconds, Fetched: 5 row(s)
    

    评价:方便、推荐使用

    2.3.2 hive 插入数据二

    hive管理的数据是放在hdfs,可以再配置文件指定存储路径,可以进入指定路径查看,也可以通过desc formatted 表名看到该表的存储路径
    在这里插入图片描述
    在这里插入图片描述

    • hive在hdfs存储的根路径是在/…/warehouse/下
    • 一个数据库对应一个文件夹,命名方式为数据库名.db(默认数据库除外)
    • 每张表也对应一个文件夹,命名方式为表名
    • 数据文件直接放在表对应的文件夹下,因此通过load方式其实底层调用的是hadoop fs -put
    • 默认数据库下的表直接放在warehouse下命名方式不变

    基于上述规律可以有第二种插入方式,直接通过hadoop的shell将文件put到指定的hdfs路径下即可

    [root@master data]# hadoop fs -put student.txt /user/hive/warehouse/hive.db/tbl_2/student_1.txt
    
    hive (hive)> select * from tbl_2;
    OK
    tbl_2.id        tbl_2.name
    1       zhangsan
    2       lisi
    3       wangwu
    4       zhaoliu
    5       tianqi
    1       zhangsan
    2       lisi
    3       wangwu
    4       zhaoliu
    5       tianqi
    Time taken: 0.396 seconds, Fetched: 10 row(s)
    

    总结:也可以用,但是必须知道表在hdfs上的路径,所以这种方式路就走窄了呀!

    看过hive数据库、表、数据在hdfs上的存储结构后,尝试再次加载一次数据,这次通过load加载hdfs上的数据

    hive (hive)> load data inpath '/student.txt' into table tbl_2;
    Loading data to table hive.tbl_2
    OK
    Time taken: 0.683 seconds
    

    load方式加载hdfs文件不需要加local(很显然),这时候再次查看hdfs信息,此时原数据将会被删除(其实就是hadoop fs -mv)
    在这里插入图片描述

    对于多次加载相同数据文件情况,hive会将数据文件重命名后上传到hdfs指定路径,重命名格式:原文件名_copy_n.txt;和windows下同名文件处理类似。

    2.4 Hive 数据类型

    2.4.1 基本数据类型

    Hive数据类型Java数据类型长度
    tinyintbyte1byte
    smalintshort2byte
    intint4byte
    bigintlong8byte
    booleanbooleantrue/false
    floatfloat单精度
    doubledouble双精度
    stringString字符串
    timestamp
    bigary

    常用的基本数据类型有int、bigint、double、string且不区分大小写;boolean一般使用0/1代替以减少存储量;string使用最多,一般都是处理日志,理论上可以存储2G数据(一行)。

    2.4.2 集合数据类型

    数据类型描述语法实例
    struct结构体,复杂无关系数据struct<k1:v,k2:v>
    map字典,键值对元组集合map<k,v>
    array数组,同一类型集合array<v>

    struct和map区别在于map只能存储一组一组的k-v对,且一个map中的k不能相同,struct可以存储很对组相同key不同value的数据结构,即map中每组数据的key都不相同,struct中每组数据对应位置的key都是一样的;集合数据类型允许任意层次的嵌套。

    2.4.3 类型转换

    Hive支持类似java的数据类型转换

    隐式转换

    • tinyint -> smalint -> int -> bigint -> float -> double
    • string类型只有是数字才可以转换
    • boolean不能转换成任意类型

    强制类型转换

    hive (hive)> select cast('1' as int);
    OK
    _c0
    1
    Time taken: 0.937 seconds, Fetched: 1 row(s)
    hive (hive)> select cast('a' as int);
    OK
    _c0
    NULL
    Time taken: 0.184 seconds, Fetched: 1 row(s)
    

    好吧,看不出什么效果

    2.4.4 测试集合数据类型

    需要存储如下格式数据(json)

    {
        "name": "陈小春",
        "friends": ["郑伊健" , "谢天华"], //列表Array
        "children": {                    //键值Map
            "jasper": 3 ,
        	"baby": 1 ,
         }
        "address": {                     //结构Struct
            "street": "皇后大道" ,
            "city": "香港"
         }
    }
    {
        "name": "刘烨",
        "friends": ["章子怡" , "孙俪"], 		
        "children": {                       
            "诺一": 8 ,
        	"霓娜": 6 ,
         }
        "address": {                       
            "street": "长安街" ,
            "city": "北京"
         }
    }
    

    将一条数据转换成一行数据,去除没必要的数据,在一条数据中,字段之间用’,‘隔开,集合元素之间用’_‘隔开,map的kv用’:'隔开,因此可以转换成如下格式

    陈小春,郑伊健_谢天华,jasper:3_baby:1,皇后大道_香港
    刘烨,章子怡_孙俪,诺一:8_霓娜:6,长安街_北京
    

    针对上述数据创建如下表

    hive (hive)> create table tbl_3(name string,friends array<string>,childress map<string,int>,address struct<street:string,city:string>)
               > row format delimited fields terminated by ','
               > collection items terminated by '_'
               > map keys terminated by ':';
    OK
    Time taken: 0.124 seconds
    

    解释:

    • row format delimited fields terminated by ','设置字段分割符
    • collection items terminated by '_'设置集合元素分割符
    • map keys terminated by ':'设置map键值对分隔符
    • lines terminated by '\n'设置行分隔符,默认\n

    导入数据测试

    hive (hive)> load data local inpath '/usr/local/soft/hive-3.2.1/data/test_collection' into table tbl_3;
    Loading data to table hive.tbl_3
    OK
    Time taken: 0.281 seconds
    hive (hive)> select * from tbl_3;
    OK
    tbl_3.name      tbl_3.friends   tbl_3.childress tbl_3.address
    陈小春  ["郑伊健","谢天华"]     {"jasper":3,"baby":1}   {"street":"皇后大道","city":"香港"}
    刘烨    ["章子怡","孙俪"]       {"诺一":8,"霓娜":6}     {"street":"长安街","city":"北京"}
    Time taken: 0.176 seconds, Fetched: 2 row(s)
    hive (hive)> select name,friends[0],childress['baby'],address.street from tbl_3;
    OK
    name    _c1     _c2     street
    陈小春  郑伊健  1       皇后大道
    刘烨    章子怡  NULL    长安街
    Time taken: 0.222 seconds, Fetched: 2 row(s)
    

    三、DDL 数据定义语言

    3.1 数据库操作

    3.1.1 创建数据库

    1.方式一

    创建一个数据库,默认存储在hdfs中/user/hive/warehouse/*.db

    hive (default)> create database test;
    OK
    Time taken: 0.827 seconds
    

    若数据库已经存在会报Execution Error,推荐使用方法二

    2.方式二

    避免创建的数据库已经存在的错误,使用if not exists写法

    hive (default)> create database if not exists hive;
    OK
    Time taken: 0.029 seconds
    

    3.方式三

    指定数据库在hdfs的存储位置

    create database test location '/hive/test.db';
    OK
    Time taken: 0.097 seconds
    

    3.1.2 查询数据库

    1.显示数据库

    显示数据库

    hive (hive)> show databases;
    OK
    database_name
    default
    hive
    Time taken: 0.03 seconds, Fetched: 2 row(s)
    

    过滤显示查询的数据库

    hive (hive)> show databases like 'h*';
    OK
    database_name
    hive
    Time taken: 0.022 seconds, Fetched: 1 row(s)
    

    2.查看数据库详情

    显示数据库信息

    hive (hive)> desc database hive;
    OK
    db_name comment location        owner_name      owner_type      parameters
    hive    hive test       hdfs://master:9000/user/hive/warehouse/hive.db  root    USER
    Time taken: 0.049 seconds, Fetched: 1 row(s)
    

    显示数据库详细信息

    hive (hive)> desc database extended hive;
    OK
    db_name comment location        owner_name      owner_type      parameters
    hive    hive test       hdfs://master:9000/user/hive/warehouse/hive.db  root    USER    {creator=wj}
    Time taken: 0.03 seconds, Fetched: 1 row(s)
    

    {creator=wj}为自定义属性,可作为注释使用

    3.1.3 修改数据库

    已经创建的数据库其信息都是不可以修改的,包括数据库名和数据库所在的目录位置等,这里修改数据库指的是修改数据库的dbproperties的键值对

    hive (test)> alter database test set dbproperties('creator'='wj');
    OK
    Time taken: 0.234 seconds
    

    3.1.4 删除数据库

    1.删除空数据库

    hive (hive)> drop database d1;
    OK
    Time taken: 0.435 seconds
    

    2.强制删除数据库

    对于非空数据库,上述命令无法删除

    hive (d1)> drop database d1;
    FAILED: Execution Error, return code 1 from org.apache.hadoop.hive.ql.exec.DDLTask. InvalidOperationException(message:Database d1 is not empty. One or more tables exist.)
    

    因此可以使用cascade进行强制删除

    hive (d1)> drop database d1 cascade;
    OK
    Time taken: 0.231 seconds
    

    3.2 表操作

    3.2.1 创建表

    标准语句

    create [external] table [if not exists] table_name
    [(col_name data_type [comment col_comment],...)]
    [comment table_comment]
    [partitioned by (col_name data_type [col_name data_type],...)]
    [clustered by (col_name,col_name)]
    [row format ...]
    [collection items ...]
    [map keys ...]
    [location hdfs_path]
    

    3.2.2 修改表

    1.表的重命名

    hive (hive)> alter table emp rename to tbl_emp;
    OK
    Time taken: 0.215 seconds
    hive (hive)> show tables;
    OK
    tab_name
    score
    student
    tbl_1
    tbl_2
    tbl_3
    tbl_4
    tbl_emp
    Time taken: 0.025 seconds, Fetched: 7 row(s)
    

    2.添加列

    hive (hive)> alter table tbl_emp add columns(emp_id int);
    OK
    Time taken: 0.147 seconds
    

    3.修改列

    包括修改列名,列属性

    hive (hive)> alter table tbl_emp change emp_id c_emp_id string;
    OK
    Time taken: 0.234 seconds
    

    替换列

    hive (hive)> alter table tbl_emp replace columns(s_id string,c_id string,c_grade string);
    OK
    Time taken: 0.157 seconds
    

    3.2.3 删除表

    hive (hive)> drop table tbl_emp;
    OK
    Time taken: 0.227 seconds
    

    3.2.4 内/外部表

    1.内部表

    又称管理表(MANAGED_TABLE),因为对应的表叫外部表(EXTERNAL_TABLE)所以喜欢叫它外部表,创建表默认是内部表,删除表时元数据和hdfs内数据均会被删除

    2.外部表

    与内部表对立,删除外部表时仅删除元数据hdfs内的数据不会被删除,再次创建同名表数据会"恢复",即hive并非认为其完全拥有此表,创建外部表命令如下:

    hive (hive)> create external table tbl_5(id int,name string);
    OK
    Time taken: 0.183 seconds
    hive (hive)> desc formatted tbl_5;
    OK
    col_name        data_type       comment
    # col_name              data_type               comment
    id                      int
    name                    string
    
    # Detailed Table Information
    Database:               hive
    OwnerType:              USER
    Owner:                  root
    CreateTime:             Thu Aug 27 19:57:54 CST 2020
    LastAccessTime:         UNKNOWN
    Retention:              0
    Location:               hdfs://master:9000/user/hive/warehouse/hive.db/tbl_5
    Table Type:             EXTERNAL_TABLE
    

    3.内外部表转换

    内部表 -> 外部表

    hive (hive)> alter table tbl_4 set tblproperties('EXTERNAL'='TRUE');
    OK
    Time taken: 0.13 seconds
    

    外部表 -> 内部表

    hive (hive)> alter table tbl_4 set tblproperties('EXTERNAL'='FALSE');
    OK
    Time taken: 0.13 seconds
    

    4.应用场景

    在实际生产环境中,涉及到共享数据一定要使用外部表,防止误操作导致的数据丢失,对于个人使用,数据分析的中间表可以使用内部表,方便管理。

    3.2.5 分区表

    假设Hive的数仓存储了一年的数据,现在需要查找出某一天的数据,当使用where语句时,Hive会对该表(文件夹)下所有数据进行全表扫描,从而导致查询效率低;因此引入分区表概念来优化查询(有谓词下推的意思)

    1.创建分区表

    hive (hive)> create table tbl_6(id int,name string) partitioned by(month string) row format delimited fields terminated by '\t';
    OK
    Time taken: 0.106 seconds
    

    在创建表语法后加partitioned by (col_name data_type)

    2.导入数据

    需要注意的是当创建的是分区表时加载数据需要添加上分区信息否则会保存(因为hive不知道要把数据put到哪个文件夹)

    hive (hive)> load data local inpath '/usr/local/soft/hive-3.2.1/data/test_partition' into table tbl_6 partition(month='2020-08');
    Loading data to table hive.tbl_6 partition (month='2020-08')
    OK
    Time taken: 0.782 seconds
    hive (hive)> select * from tbl_6;
    OK
    tbl_6.id        tbl_6.name      tbl_6.month
    1       tzhangsan       2020-08
    2       tlisi   2020-08
    3       twangwu 2020-08
    Time taken: 0.141 seconds, Fetched: 3 row(s)
    

    可以发现分区字段会自动加到表的数据中(原始数据文件不会被添加,hive自己做的处理,在读取数据的时候自动添加分区字段数据),添加多个分区后

    hive (hive)> load data local inpath '/usr/local/soft/hive-3.2.1/data/test_partition' into table tbl_6 partition(month='2020-09');
    Loading data to table hive.tbl_6 partition (month='2020-09')
    OK
    Time taken: 0.634 seconds
    

    在这里插入图片描述

    因此分区的本质就是分文件夹,文件夹以分区名命名,不同分区的数据被放在不同文件夹下,这样的好处是当执行where查询时,hive会直接去指定的分区文件夹下扫描数据,效率将大幅提高。

    3.操作分区

    添加分区(本质就是创建文件夹)

    hive (hive)> alter table tbl_6 add partition(month='2020-10');
    OK
    Time taken: 0.169 seconds
    

    删除分区(本质就是删除文件夹)

    hive (hive)> alter table tbl_6 drop partition(month='2020-10');
    OK
    Time taken: 0.269 seconds
    

    创建二级分区

    hive (hive)> create table tbl_6(id int,name string) partitioned by(month string,day string) 
    row format delimited fields terminated by '\t';
    OK
    Time taken: 0.106 seconds
    

    理论、操作都一样,多级分区上限没有限制(适可而止),结合上面知识,向分区表插入数据也可以直接put文件到指定路径

    查看分区

    hive (hive)> show partitions tbl_6;
    OK
    partition
    month=2020-08
    month=2020-09
    month=2020-10
    Time taken: 0.127 seconds, Fetched: 3 row(s)
    

    四、DML 数据操作语言

    4.1 数据导入

    4.1.1 向表中转载数据(load)

    1.标准语法

    load data [local] inpath path [overwrite] into table table_name [partition(p1=v1,...)]
    
    argsexplain
    load data加载数据
    local加载本地文件,不加默认加载hdfs
    inpath path加载数据文件的路径
    overwrite覆盖已有数据
    into table追加数据
    table_name具体的表名
    partition加载数据到指定分区

    2.操作案例

    见2.3 Hive常规操作

    4.1.2 insert

    insert插入分区表,真不推荐使用这个

    hive (hive)> insert into tbl_6 partition(month='2020-07') values(4,'zhaoliu');
    

    基本插入模式,根据查询的结果插入数据

    hive (hive)> insert into table tbl_5 select * from tbl_1;
    
    hive (hive)> insert overwrite table tbl_5 select * from tbl_1;
    

    4.1.3 as select

    hive (hive)> create table tbl_7 as select * from tbl_6;
    

    4.1.4 export

    只能搭配import使用,见下面的inport用法

    4.2 数据导出

    4.2.1 insert

    hive (hive)> insert overwrite local directory '/tmp/hive' select * from tbl_6;
    
    [root@master data]# cd /tmp/hive/
    [root@master hive]# ll
    总用量 4
    -rw-r--r--. 1 root root 108 8月  27 20:55 000000_0
    [root@master hive]# cat 000000_0
    1tzhangsan2020-08
    2tlisi2020-08
    3twangwu2020-08
    1tzhangsan2020-09
    2tlisi2020-09
    3twangwu2020-09
    

    导出的数据会把导出路径下的所有文件进行覆盖,一定要写一个不存在的路径。但cat文件发现数据不友好,因此需要格式化导出数据

    hive (hive)> insert overwrite local directory '/tmp/hive' row format delimited fields terminated by '\t' select * from tbl_6;
    
    [root@master hive]# cat 000000_0
    1       tzhangsan       2020-08
    2       tlisi   2020-08
    3       twangwu 2020-08
    1       tzhangsan       2020-09
    2       tlisi   2020-09
    3       twangwu 2020-09
    

    4.2.2 hive shell

    不常用hive -e ‘sql’ > file 利用linux的重定向

    4.2.3 export/import

    先导出后导入

    hive (hive)> export table tbl_1 to '/hive';
    OK
    Time taken: 0.117 seconds
    hive (hive)> truncate table tbl_1;
    OK
    Time taken: 0.149 seconds
    hive (hive)> select * from tbl_1;
    OK
    tbl_1.id        tbl_1.name
    Time taken: 0.141 seconds
    hive (hive)> import table tbl_1 from '/hive';
    Copying data from hdfs://master:9000/hive/data
    Copying file: hdfs://master:9000/hive/data/000000_0
    Loading data to table hive.tbl_1
    OK
    Time taken: 0.197 seconds
    

    五、DQL 数据查询语言

    5.1 本地模式

    对于数据量小,学习一些操作命令可以将hive的运行模式设置成本地模式。对于小数据集可以明显的缩短时间,通过如下配置

    //开启本地模式
    set hive.exec.mode.local.auto=true;
    //设置local mr最大输入数据量,当数据量小于这个值(默认128M)时使用local mr
    set hive.exec.mode.local.auto.inputbytes.max=50000000;
    //设置local mr最大输入文件数,当文件数小于这个值(默认4)时使用local mr
    set hive.exec.mode.local.auto.input.files.max=10;
    

    关闭本地模式

    set hive.exec.mode.local.auto=true;
    

    5.2 基本查询

    和mysql语法一致,基本语法

    select ... from table_name
    

    5.2.1 全表和特定字段查询

    1.全表查询

    select * from student;
    

    2.特定字段查询

    select st_id,st_name from student;
    

    总结:

    1. HQL语法不区分大小写
    2. HQL可以写一行也可以写多行
    3. 关键字不能被缩写或换行
    4. 字句一般分行写
    5. 多使用缩进提高代码可读性

    5.2.2 列起别名

    基本语法,as可以省略

    select st_id as id,st_name name from student;
    

    5.2.3 算术运算符

    运算符描述
    A+BA和B相加
    A-BA减去B
    A*BA和B相乘
    A/BA除以B
    A%BA对B取余
    A&BA和B按位取与
    A|BA和B按位取或
    A^BA和B按位取异或
    ~AA按位取反

    5.2.4 limit 语句

    基本语法

    select st_id,st_name from student limit 2;
    

    5.2.5 where 语句

    和mysql语法一致,基本语法

    select * from student where st_age > 20;
    

    1.比较运算符

    操作符支持的数据类型描述
    A=B基本数据类型如果A等于B则返回TRUE,反之返回FALSE
    A!=B基本数据类型如果A不等于B,则返回TRUE,反之返回FALSE
    A<B基本数据类型如果A小于B,则返回TRUE,反之返回FALSE
    A<=B基本数据类型如果A小于等于B,则返回TRUE,反之返回FALSE
    A>B基本数据类型如果A大于B,则返回TRUE,反之返回FALSE
    A>=B基本数据类型如果A大于等于B,则返回TRUE,反之返回FALSE
    A [NOT] BETWEEN B AND C基本数据类型如果A的值大于等于B而且小于或等于C,则结果为TRUE,反之为FALSE。如果使用NOT关键字则可达到相反的效果。
    A IS NULL所有数据类型如果A等于NULL,则返回TRUE,反之返回FALSE
    A IS NOT NULL所有数据类型如果A不等于NULL,则返回TRUE,反之返回FALSE
    IN(数值1, 数值2)所有数据类型等于数值1、数值2,返回TRUE
    A [NOT] LIKE BSTRING 类型B是一个SQL下的简单正则表达式,如果A与其匹配的话,则返回TRUE;反之返回FALSE。B的表达式说明如下:‘x%‘表示A必须以字母’x’开头,’%x’表示A必须以字母’x’结尾,而’%x%‘表示A包含有字母’x’,可以位于开头,结尾或者字符串中间。如果使用NOT关键字则可达到相反的效果。

    2.逻辑运算符

    操作符含义
    AND逻辑并
    OR逻辑或
    NOT逻辑否

    5.4 分组查询

    和mysql语法一致

    5.4.1 group by

    group by语句通常会和聚合函数(count、max、min、avg、sum)一起使用,按照一个或者多个列队结果进行分组,然后对每个组执行聚合操作。同样select的字段必须出现在group by后或者聚合函数里

    select st_dept,count(*) from student group by st_dept;
    

    5.4.2 having

    用法和mysql一样

    having和where区别:

    1. where对表中的列发挥作用,having对查询结果的列发挥作用
    2. where后面不能接聚合函数,having后面可以接聚合函数
    3. having只能用在group by后面

    5.5 连接查询

    5.5.1 等值连接

    Hive只支持等值连接,不支持非等值连接,其用法可mysql语法一致

    5.5.2 总结

    内连接、左连接、右连接、满连接、多表连接、笛卡尔积都和mysql语法一致

    5.6 排序

    hive的排序将会和mysql有很大的区别,为了更好的展现hive的排序,需要了解hive配置

    hive (hive)> set mapreduce.job.reduces;
    mapreduce.job.reduces=-1
    

    设置reduce个数,默认-1会根据sql、数据量等动态规划reduce个数,通过设置大于0的数来规定reduce个数

    5.6.1 全局排序

    就是MapReduce的全局排序,在hive中体现为order by对应一个reduce,因为站在MapReduce角度全局排序必须输出一个文件因此必须只有一个reduce。

    1.使用

    select * from student order by age;
    

    同样默认升序(asc),可以按降序排序(desc)

    2.细节

    当使用order by排序是会启动一个reduce,那么当手动设置reduce个数最终会启动几个reduce呢?

    //设置reduce个数为3
    hive (test)> set mapreduce.job.reduces=3;
    hive (test)> select * from student order by age;
    Query ID = root_20200829092604_3b647fd2-3d10-46ac-b498-0f34941dee6a
    Total jobs = 1
    Launching Job 1 out of 1
    ...
    Hadoop job information for Stage-1: number of mappers: 1; number of reducers: 1
    

    提交一个job,启动一个reduce,发现无论设置多少个reduce个数全局排序就只会启动一个redcue。

    3.补充

    支持别名排序

    select stu_id id  from student order by id;
    

    支持多个字段排序

    hive (test)> select * from student order by age,stu_id;
    

    5.6.2 局部排序

    对应MapReduce多个reduce,每个reduce局部有序,不一定保证全局有序,hive中通过sort by实现。

    设置reduce个数为三

    set mapreduce.job.reduces=3;
    

    具体实现

    hive (test)> select * from emp sort by deptno desc;
    ...
    Hadoop job information for Stage-1: number of mappers: 1; number of reducers: 3
    

    结果如下
    在这里插入图片描述

    可以大致看出是分三个区(三个reduce即对应三个分区),当然可以将结果输出到文件中可以发现也是三个文件

    insert overwrite local directory '/tmp/hive' 
    select * from emp sort by deptno desc;
    

    但问题是在MapReduce中分区默认为HashPartitioner根据key的hash和reduce个数取余,那么hive是怎么实现分区呢?按照哪(几)个字段实现分区?从官方文档可以找到答案,按照上述没有指定分区的hql来说hive通过随机值的形式分区。
    在这里插入图片描述

    为什么?当我们没有指定字段分区时,若hive还按照字段进行分区万一导致数据倾斜问题该找谁呢?所以hive通过随机加载的形式尽可能减少数据倾斜的发生。

    5.6.3 分区排序

    distribute by:类似MapReduce的partition,通过指定某个字段进行分区(HashPartitioner)结合sort by从而达到分区内有序

    按照部门id分区,分区内按照薪资升序排序

    hive (test)> select * from emp distribute by deptno sort by sal;
    

    在这里插入图片描述

    5.6.4 cluster by

    当distribute by和sort by字段一致时可以使用cluster by代替,因此distribute by兼顾分区和排序两个功能,但是cluster by排序只支持降序排序,不能指定desc或asc一句话

    cluster by col <=> distribute by col sort by col
    

    那么有人就问了对一个字段分区又排序的意义可在?当我们数据有很多是,分区数少但该字段类型有很多种,因此就会有很多字段进入同一个分区,在对同一个分区按照该字段排序。

    5.6.5 总结

    语法总结
    group by对字段进行分区,将相同字段再进行分区,后面会接聚合操作
    distribute by仅对字段进行分区
    order by全局排序,只会起一个reduce
    sort by局部排序,若设置reduce个数为1则和order by一样

    5.7 分桶表

    请区别于分区表(我觉得这两张表的名字起得不太友好),学完发现分区表仅是数据分开存储,分桶表则对应MR的分区,将数据文件分开存储;注意分区表针对的是数据的存储路径,将一个个文件分文件夹存储,分桶表则是对一个个文件进行分区,一个分区对应一个文件即对一份数据文件进行了拆分。

    分区提供一个数据隔离和优化查询的便利方式,但不是所有的数据集都能形成比较好的分区;分桶则是将数据集拆分成更容易管理的若干部分的另一种手段。

    5.7.1 创建分桶表

    create table stu_buck(id int, name string)
    clustered by(id) into 4 buckets
    row format delimited fields terminated by '\t';
    

    分桶表使用clustered by(注意和分区排序区分开)且字段要是表中的字段(分区字段不能是表中字段)且分4个桶

    查看表结构

    hive (test)>  desc formatted stu_buck;
    

    在这里插入图片描述

    加载数据到分桶表中,加载之前要确保mapreduce.job.reduces=-1这样hive会根据分桶表中的分桶数自动创建对应数量的reduce数
    在这里插入图片描述
    大致可以看出按照id的hash值取余
    在这里插入图片描述

    看了很多的文章发现创建分桶表步骤很多,首先开启分桶开关之类的,但发现在hive 3.1.2版本这个配置已经不存在了

    hive (test)> set hive.enforce.bucketing;
    hive.enforce.bucketing is undefined
    

    通过阅读官方文档发现hive 2.x直接load数据即可,不需要通过创建中间表,再通过中间表走MR插入到分桶表的形式来加载数据了
    在这里插入图片描述

    5.7.2 分桶表应用

    对于分桶表主要用于抽样查询中,在一个庞大的数据集中往往需要一个代表性查询结果而不是全部查询结果,因此hive通过抽样语句来实现抽样查询

    tablesample(bucket x out of y on col)
    

    col:为分桶字段

    x:表示从哪个桶开始抽取

    y:必须是分桶数的倍数或者因子,决定抽样的比例。如假设分桶数为4,当y=2时,抽取(4/2)=2个桶的数据;当y=4时,抽取(4/4)=1个桶的数据;当y=8时,抽取(4/8)=1/2个桶的数据

    假设分桶数z:z/y>1,则最终取x,x+z/y+z/y*2…

    tablesample(bucket 1 out of 2 on id)
    

    即从第一个桶开始抽,抽取两个桶的数据,也就是抽取1,3两个桶中的数据

    因此tablesample要求x <= y,因为抽取的最后一个为

    x+(z/y-1)*y => x+z-y <= z => x <= y
    

    若x > y会报FAILED: SemanticException [Error 10061]: Numerator should not be bigger than denominator in sample clause for table stu_buck

    六、函数

    hive的函数和mysql一样分为系统内置函数和用户自定义函数,只是自定义函数和mysql将会有巨大差别

    查看系统内置函数

    hive (test)> show functions;
    

    查看内置函数用法

    hive (test)> desc function upper;
    

    查看内置函数详细用法

    hive (test)> desc function extended upper;
    

    6.1 系统内置函数

    下面列举常用的内置函数,主要介绍和mysql不同的部分(带*的)[一共216个]

    functionexplanation
    round四舍五入
    ceil向上取整
    floor向下取整
    rand取0-1随机数
    lower转小写
    upper转大写
    length返回字符串长度
    concat字符串拼接
    concat_ws指定分隔符拼接
    collect_set合并字段*
    substr求子串
    trim前后去空格
    split字符串分割
    to_date字符串转日期
    year、month…从日期中提取年月日
    from_unixtime时间戳转日期*
    unix_timestamp日期转时间戳*
    case…when…条件函数
    if判断函数
    count求个数(聚合)
    sum求总和(聚合)
    min求最小值(聚合)
    max求最大值(聚合)
    avg求平均值(聚合)
    explode膨胀函数*
    lateral view拓展explode*
    over开窗函数

    6.1.1 collect_set

    通常搭配group by使用,将每个组的数据收集(collect)起来封装成一个集合(set)。
    在这里插入图片描述

    具体用法

    hive (test)> select college,collect_set(stu_name) from student group by college;
    ...
    mr
    ...
    ES      ["郑楠","宋夏","刘甜甜","张海涛","张晓燕","张伟","刘梦"]
    IS      ["李娜","刘勇","邓丽丽","刘小棠","张丽丽","孙鹏"]
    MA      ["张婷","李学文","张海玲","高小海","刘小鹏","郑成功","李国伟","周宏伟","孙海波"]
    
    

    按学院分组,打印出每个学员信息和每个学院都有哪些学生,使用collect_set函数将同学院学生封装集合

    6.1.2 日期相关

    日期转时间戳 unix_timestamp

    hive (test)> select unix_timestamp('2020-08-29 14:14:00','yyyy-MM-dd HH:mm:ss');
    OK
    _c0
    1598710440
    Time taken: 0.24 seconds, Fetched: 1 row(s)
    

    时间戳转日期 from_unixtime

    hive (test)> select from_unixtime(1598710440,'yyyy-MM-dd HH:mm:ss');
    OK
    _c0
    2020-08-29 14:14:00
    Time taken: 0.146 seconds, Fetched: 1 row(s)
    

    6.1.3 膨胀函数

    1.explode

    将一行数据转换成列,在hive中只能用于array和map数据类型

    用于array数据类型

    hive (hive)> select * from tbl_3;
    OK
    tbl_3.name      tbl_3.friends   tbl_3.childress tbl_3.address
    陈小春  ["郑伊健","谢天华"]     {"jasper":3,"baby":1}   {"street":"皇后大道","city":"香港"}
    刘烨    ["章子怡","孙俪"]       {"诺一":8,"霓娜":6}     {"street":"长安街","city":"北京"}
    Time taken: 0.153 seconds, Fetched: 2 row(s)
    
    hive (hive)> select explode(friends) as friend from tbl_3;
    OK
    friend
    郑伊健
    谢天华
    章子怡
    孙俪
    Time taken: 0.156 seconds, Fetched: 4 row(s)
    

    用于map数据类型

    hive (hive)> select explode(childress) as (name,age) from tbl_3;
    OK
    name    age
    jasper  3
    baby    1
    诺一    8
    霓娜    6
    Time taken: 0.133 seconds, Fetched: 4 row(s)
    

    但是explode函数有很大的缺陷

    1. 不能关联原表的其他字段
    2. 不能分组、排序
    3. 不能进行UDTF(用户自定义表生成函数)嵌套

    2.lateral view

    lateral view是hive中提供给UDTF的结合,它可以解决UDTF不能添加额外select的问题,其原理是lateral view类似mysql视图,将UDTF(接收一行输入,输出多行,explode就是UDTF)结果保存为一个视图(虚拟表)并和输入行进行join来达连接其他字段的select的目的。

    标准语法

    lateral view udtf(expression) tableAlias as columnAlias,columnAlias...
    

    udtf(expression):使用的UDTF函数。如explode()

    tableAlias:表示虚拟表表名

    columnAlias:给虚拟表取的字段名,多个字段用,隔间

    解决explode()带来的不足

    hive (hive)> select name, friend from tbl_3 lateral view explode(friends) tmp_tbl as friend;
    OK
    name    friend
    陈小春  郑伊健
    陈小春  谢天华
    刘烨    章子怡
    刘烨    孙俪
    Time taken: 0.086 seconds, Fetched: 4 row(s)
    

    6.2 用户自定义函数

    hive中的自定义函数根据输入输出行数分为三种:

    • 用户定义函数(user-defined function)UDF
    • 用户定义聚集函数(user-defined aggregate function)UDAF
    • 用户定义表生成函数(user-defined table-generating)UDTF
    函数类型描述
    UDF一行输入一行输出,如字符串类函数
    UDAF多行输入一行输出,如聚合函数
    UDTF一行输入多行输出,如膨胀函数

    6.2.1 UDF

    1.编程步骤

    1. 继承org.apache.hadoop.hive.ql.exec.UDF
    2. 实现evaluate函数,该函数支持重载
    3. hive中添加jar包
    4. 创建函数
    5. 使用函数
    6. 删除函数

    注意:UDF必须有返回值,可以返回null,但不能不返回

    2.具体实现

    实现length()函数功能

    1)添加依赖

    <dependency>
    	<groupId>org.apache.hive</groupId>
    	<artifactId>hive-exec</artifactId>
    	<version>3.1.2</version>
    </dependency>
    

    2)创建类继承UDF

    package hive.udf;
    
    import org.apache.hadoop.hive.ql.exec.UDF;
    
    @SuppressWarnings("deprecation")
    public class UDFLength extends UDF {
    
    }
    

    3)实现evaluate函数

    package hive.udf;
    
    import org.apache.hadoop.hive.ql.exec.UDF;
    
    @SuppressWarnings("deprecation")
    public class UDFLength extends UDF {
        public int evaluate(String str) {
            return str.length();
        }
    }
    

    4)hive中添加jar包

    将程序达成jar包,放入hive/lib下,这个包下jar在hive启动时会自动加载,当然也可以手动加载jar包

    hive (hive)> add jar /usr/local/soft/hive-3.2.1/lib/hadoop-1.0-SNAPSHOT.jar;
    Added [/usr/local/soft/hive-3.2.1/lib/hadoop-1.0-SNAPSHOT.jar] to class path
    Added resources: [/usr/local/soft/hive-3.2.1/lib/hadoop-1.0-SNAPSHOT.jar]
    

    5)创建函数

    hive中自定义函数创建时可以分为临时函数和永久函数,对于临时函数仅在当前session,当前数据库起作用。

    标准语法

    create [temporary] function fun_name as 'package.class';
    
    hive (hive)> create temporary function getlength as 'hive.udf.UDFLength';
    OK
    Time taken: 0.047 seconds
    

    6)使用函数

    根据逻辑传入一个字符串返回一个int

    hive (hive)> select *,getlength(st_name) from student;
    OK
    student.st_id   student.st_name student.st_sex  student.st_age  student.st_dept _c1
    10001   郑楠    男      20      ES      2
    10002   李娜    女      19      IS      2
    Time taken: 0.145 seconds, Fetched: 2 row(s)
    
    hive (hive)> desc function extended getlength;
    OK
    tab_name
    There is no documentation for function 'getlength'
    Function class:hive.udf.UDFLength
    Function type:TEMPORARY
    Time taken: 0.017 seconds, Fetched: 3 row(s)
    

    7)删除函数

    hive (hive)> drop function if exists getlength;
    OK
    Time taken: 0.648 seconds
    

    6.2.2 GenericUDF

    UDF类已经过时,hive推荐使用GenericUDF,该类支持更多的数据类型且效率更高

    package hive.udf;
    
    import org.apache.hadoop.hive.ql.exec.UDFArgumentException;
    import org.apache.hadoop.hive.ql.metadata.HiveException;
    import org.apache.hadoop.hive.ql.udf.generic.GenericUDF;
    import org.apache.hadoop.hive.serde2.objectinspector.ObjectInspector;
    
    public class GenericUDFLength extends GenericUDF {
        @Override
        public ObjectInspector initialize(ObjectInspector[] arguments) throws UDFArgumentException {
            return null;
        }
    
        @Override
        public Object evaluate(DeferredObject[] arguments) throws HiveException {
            return null;
        }
    
        @Override
        public String getDisplayString(String[] children) {
            return null;
        }
    }
    
    • initialize初始化,可以进行参数校验,对象实例化等等
    • evaluate业务逻辑
    • getDisplayString显示函数的帮助信息

    那么initialize里面些什么呢?打开一个GenericUDF的实现类GenericUDFCharacterLength

    @Description(name = "character_length,char_length",
        value = "_FUNC_(str | binary) - Returns the number of characters in str or binary data",
        extended = "Example:\n"
        + "  > SELECT _FUNC_('안녕하세요') FROM src LIMIT 1;\n" + "  5")
    

    这个函数应该是韩国人写的,我们可以看他的initialize返回的是啥

    outputOI = PrimitiveObjectInspectorFactory.writableIntObjectInspector;
    return outputOI;
    

    大致明白通过PrimitiveObjectInspectorFactory里的静态变量返回该函数需要返回的值,推测他的函数应该返回int类型,因此我们也可以直接返回

    @Override
    public Object evaluate(DeferredObject[] arguments) throws HiveException {
    	return null;
    }
    

    这个evaluate显然是优于UDF的,可是让我们函数接受任意多任意类型的值。

    package hive.udf;
    
    import org.apache.hadoop.hive.ql.exec.UDFArgumentException;
    import org.apache.hadoop.hive.ql.metadata.HiveException;
    import org.apache.hadoop.hive.ql.udf.generic.GenericUDF;
    import org.apache.hadoop.hive.serde2.objectinspector.ObjectInspector;
    import org.apache.hadoop.hive.serde2.objectinspector.primitive.PrimitiveObjectInspectorFactory;
    import org.apache.hadoop.io.IntWritable;
    
    public class GenericUDFLength extends GenericUDF {
        IntWritable result = new IntWritable();
    
        @Override
        public ObjectInspector initialize(ObjectInspector[] arguments) throws UDFArgumentException {
            return PrimitiveObjectInspectorFactory.writableIntObjectInspector;
        }
    
        @Override
        public IntWritable evaluate(DeferredObject[] arguments) throws HiveException {
            if (arguments.length > 1) {
                System.out.println("该函数暂时不支持多个参数");
                return null;
            }
            result.set(arguments[0].get().toString().length());
            return result;
        }
    
        @Override
        public String getDisplayString(String[] children) {
            return "获取字符串长度";
        }
    }
    
    hive (default)> create temporary function getlength as 'hive.udf.GenericUDFLength';
    OK
    Time taken: 0.519 seconds
    hive (default)> select getlength('123');
    OK
    _c0
    3
    Time taken: 3.072 seconds, Fetched: 1 row(s)
    

    这里有坑,避免java的强制类型转换,返回值建议返回hadoop的数据类型

    6.2.2 UDAF

    UDAF区别于UDF是UDAF需要接受任意多个值后再进行计算后返回,因此UDAF的结构将比UDA复杂

    1.编程步骤

    1. 函数类继承AbstractGenericUDAFResolver、计算类实现GenericUDAFEvaluator接口
    2. 实现UDAFEvaluator接口的inititerateterminatePartialmergeterminate
      1. init初始化
      2. iterate接收传入参数,进行内部迭代
      3. terminatePartial返回iterate后的数据
      4. merge接收terminatePartial返回结果,进行merge操作
      5. terminate返回最终的结果

    2.具体实现

    6.2.3 UDTF

    实现split函数功能

    1.编程步骤

    1. 创建一个类继承GenericUDTF
    2. 实现initializeprocessclose方法

    发现GenericUDTF仅需要我们重写processclose两个方法,实际操作发现会报错,为什么?从GenericUDTF源码可以看出

    public StructObjectInspector initialize(StructObjectInspector argOIs)
          throws UDFArgumentException {
        List<? extends StructField> inputFields = argOIs.getAllStructFieldRefs();
        ObjectInspector[] udtfInputOIs = new ObjectInspector[inputFields.size()];
        for (int i = 0; i < inputFields.size(); i++) {
          udtfInputOIs[i] = inputFields.get(i).getFieldObjectInspector();
        }
        return initialize(udtfInputOIs);
      }
      
    @Deprecated
      public StructObjectInspector initialize(ObjectInspector[] argOIs)
          throws UDFArgumentException {
        throw new IllegalStateException("Should not be called directly");
      }
    

    源码直接抛出异常,因此我们必须重写initialize

    2.代码实现

    同理查看别人怎么实现的GenericUDTFJSONTuple
    在这里插入图片描述

    纵观它的初始化逻辑很简单,numCols为方法形参数据的长度,fieldNames保存函数返回值字段名,fieldOIs保存函数返回值类型,因此我们可以写出自己的初始化,同时实现自己的逻辑

    package hive.udtf;
    
    import org.apache.hadoop.hive.ql.exec.UDFArgumentException;
    import org.apache.hadoop.hive.ql.metadata.HiveException;
    import org.apache.hadoop.hive.ql.udf.generic.GenericUDTF;
    import org.apache.hadoop.hive.serde2.objectinspector.ObjectInspector;
    import org.apache.hadoop.hive.serde2.objectinspector.ObjectInspectorFactory;
    import org.apache.hadoop.hive.serde2.objectinspector.StructObjectInspector;
    import org.apache.hadoop.hive.serde2.objectinspector.primitive.PrimitiveObjectInspectorFactory;
    import org.apache.hadoop.io.Text;
    
    import java.util.ArrayList;
    import java.util.List;
    
    public class UDTFSplit extends GenericUDTF {
    
        //保存字符串分割后的数据,用于多行输出
        Text result = new Text();
    
        public StructObjectInspector initialize(StructObjectInspector argOIs)
                throws UDFArgumentException {
            List<String> fieldNames = new ArrayList<>();
            List<ObjectInspector> fieldOIs = new ArrayList<>();
            // 这个字段最终会显示为结果的字段名
            fieldNames.add("结果");
            // 申明函数返回值类型
            fieldOIs.add(PrimitiveObjectInspectorFactory.writableStringObjectInspector);
            return ObjectInspectorFactory.getStandardStructObjectInspector(fieldNames, fieldOIs);
        }
    
    
        @Override
        public void process(Object[] args) throws HiveException {
            if (args.length != 2) {
                throw new RuntimeException("参数个数不匹配");
            }
            //第一个参数为待分割的字符串
            String[] split = args[0].toString().split(args[1].toString());
            for (String value : split) {
                result.set(value);
                //类似context.write()
                forward(result);
            }
        }
    
        @Override
        public void close() throws HiveException {
            //可以在这里实现一些关流操作
        }
    }
    

    使用

    hive (default)> select udtfsplit('hello_world_hello_hive','_');
    OK
    结果
    hello
    world
    hello
    hive
    Time taken: 2.406 seconds, Fetched: 4 row(s)
    

    七、企业调优

    说实话,关于hive调优没有几年的工作经验是写不出来的,关键面试还贼爱问这个,因此就只能背了(待总结);实际生产有的不多,为什么呢?对于一般人来说,能把需求的sql写出来就谢天谢地了还祈求什么调优啊,需求都没实现拿什么调优!!!是不是。

    • fetch抓取
    • 本地模式
    • 表的优化
    • MR优化
    • 并行执行
    • 严格模式
    • JVM重用
    • 推测执行
    • 压缩
    展开全文
  • hive(一)hive的安装与基本配置

    千次阅读 2022-04-11 09:31:40
    安装hive所需要的虚拟机环境为虚拟机安装有Hadoop并且集群成功,同时Hadoop需要在启动状态下,同时需要安装有mysql。不需要有zookeeper和HA,由于HA中含有大量进程,启动会占用很多资源,建议不要有HA 二、安装步骤...
  • Hive 2.3.3 安装指南

    千次阅读 2022-04-22 21:46:55
    本教程全面介绍了Hive安装配置,并详细介绍了Hive文件配置,以及常见错误,让初学者也能轻易地完成数据仓库安装。
  • Hive 3 安装部署教程

    万次阅读 多人点赞 2021-06-20 01:27:54
    前言 本文隶属于专栏《100个问题搞定大数据安装...自行按照教程提示下载 Hive 安装包 或者使用笔者提供的 Hive 安装包——Hive3.1.2安装包 下载hive 下载地址 打开下载地址后,如下图点击 apache-hive-3.1.2-bin.tar.gz
  • Hive 元数据服务 MetaStore

    千次阅读 2022-04-26 23:25:20
    MetaSore 是 Hive 元数据存储的地方。Hive 数据库、表、函数等的定义都存储在 MetaStore 中。根据系统配置方式,统计信息和授权记录也可以存储在这。Hive 或者其他执行引擎在运行时可以使用这些数据来确定如何解析,...
  • 原来HIVE 还有这样的坑?

    千次阅读 2022-06-29 01:19:40
    1 从调度系统对 HIVE 作业的调度策略聊起大家知道,依托 HIVE 构建数据仓库时,我们一般会通过调度系统精心编排 HIVE SQL 作业,以避免多个作业并发写同一张表或同一个表分区;同时 AD HOC 的数据查询操作,在时间上...
  • 万字长文深度剖析 HIVE3

    千次阅读 2022-05-28 01:23:30
    HIVE3 深度剖析 (上篇)大家好,我是峰哥!今天给大家推荐一篇干货文章~...整个系列分为上下两篇文章,涵盖以下章节:从 HIVE 架构的演进看 HIVE 的发展趋势盘点下 HIVE3.X 和 HIVE2.X 的那些重大差异点HIVE3.X 的 OR...
  • Hive 快速入门与平台搭建 | 结合Mysql

    万次阅读 2021-11-22 15:39:49
    Hive介绍 Apache Hive 是一款基于 Hadoop 的数据仓库软件 Hadoop 为商品硬件上的数据存储和处理提供了大规模扩展和容错能力. Hive 的设计目的是为了方便地进行数据的汇总、临时查询和大量数据的分析 它支持 SQL 语句...
  • hive搭建

    千次阅读 2022-03-16 17:04:17
    step: 1.准备好hadoop环境 2.准备MySQL环境 (因为hive的元数据数据库是...4.安装hive并配置hive的安装环境 (解决架包冲突mv $HIVE_HOME/lib/log4j-slf4j-impl-2.10.0.jar $HIVE_HOME/lib/log4j-slf4j-impl-2.10..
  • 最近在利用FlinkSQL进行开发连接Hive数据库的时候遇到了一些小问题,接下来分享给大家以免以后踩坑。 在一个项目中我主要利用FlinkSQL来连接Hive数据库并执行Insert动态插入语句来关联设备信息,话不多说我们直接开始...
  • Flink1.12.2集成hudi0.9.0+同步hive实践

    千次阅读 2021-09-07 09:49:11
    目录 一、组件下载 二、Batch模式实施步骤: 2.1 启动flink-sql客户端 2.2 创建表 2.3插入数据 ...四.Hive 同步 ...2.在 Hive 服务器导入 Hudi 包 4.3. Hive 配置模版 3.1源表的建表语句: 3.1..
  • 1 什么是Hive? 首先给大家介绍一下什么是HiveHive是Facebook为了解决海量数据的统计分析,而开发的基于Hadoop的一个数据分析工具(也就证明了Hive没有存储数据的能力,它只有使用数据的能力),而且是将结构化的...
  • Hive安装超详细教程

    千次阅读 2022-05-19 20:27:40
    Hive3.1.2安装教程前言初始准备安装Hive的具体步骤1、下载hive安装包2、解压3、添加Hive核心配置,选择远程MySQL模式4、下载连接MySQL的驱动包到hive的lib目录下5、在MySQL上创建Hive的元数据存储库6、执行Hive的...
  • 工作中遇到的hive常见报错及问题

    万次阅读 2021-10-14 16:45:29
    1,执行#hive命令进入Hive CLI时报如下错误: Exception in thread "main" java.lang.RuntimeException: java.lang.RuntimeException: Unable to instantiate org.apache.hadoop.hive.ql.metadata....
  • spark sql读写hive的过程

    千次阅读 2022-01-17 15:47:57
    Spark sql读写hive需要hive相关的配置,所以一般将hive-site.xml文件放到spark的conf目录下。代码调用都是简单的,关键是源码分析过程,spark是如何与hive交互的。 1. 代码调用 读取hive代码
  • Hive基本SQL操作(图文并茂)

    万次阅读 多人点赞 2020-06-21 19:20:38
    Hive基本SQL操作 Hive DDL(数据库定义语言) 1、数据库的基本操作 --展示所有数据库 show databases; --切换数据库 use database_name; /*创建数据库 CREATE (DATABASE|SCHEMA) [IF NOT EXISTS] database_name...
  • 文章目录版本情况:一、Hive的嵌入模式安装原因分析:二、Hive的本地模式安装 版本情况: apache-hive-1.2.1-bin.tar mysql-connector-java-5.1.40.tar ubuntu 16.04 相关软件网盘链接 链接:...
  • 8、Hive数据仓库——环境搭建及简单使用

    千次阅读 多人点赞 2022-02-17 18:46:30
    Hive 是建立在 Hadoop 上的数据仓库基础构架。它提供了一系列的工具,可以用来进行数据提取转化加载(ETL ),这是一种可以存储、查询和分析存储在 Hadoop 中的大规模数据的机制。Hive 定义了简单的类 SQL 查询语言...
  • hive3.1集群搭建

    千次阅读 2022-04-14 23:30:04
    hive3.1集群搭建 Hive 3新特性 不再支持Mr,取而用Tez 查询引擎,且支持两种查询模式:Container 和 LLAP Hive CLI不再支持(被beeline取代) SQL Standard Authorization 不再支持,且默认建的表就已经是ACID表 ...
  • hive架构详解

    千次阅读 2020-08-28 20:41:32
    hive是facebook开源,并捐献给了apache组织,作为apache组织的顶级项目(hive.apache.org)。 hive是一个基于大数据技术的数据仓库(DataWareHouse)技术,主要是通过将用户书写的SQL语句翻译成MapReduce代码,然后发布...
  • 大数据开发-hive(入门篇)

    万次阅读 多人点赞 2020-08-29 17:25:13
    大数据分析利器之hive 一、环境准备 安装好对应版本的hadoop集群 安装mysql服务 二、知识要点 1. Hive是什么(40分钟) 1.1 hive的概念 Hive:由Facebook开源,用于解决海量结构化日志的数据统计。 Hive是基于...
  • Hive学习(1)配置参数

    万次阅读 2020-12-07 16:43:14
    hive.exec.mode.local.auto.inputbytes.max 如果 hive.exec.mode.local.auto 为 true,当输入文件大小小于此阈值时可以自动在本地模式运行,默认是 128兆。 134217728L hive.exec.mode.local.auto 决定 Hive ...
  • Hive安装详细步骤

    千次阅读 2020-10-31 18:04:37
    一、下载hive 下载hive——地址:http://mirror.bit.edu.cn/apache/hive/ 二、安装mysql 执行以下几个命令安装mysql su - root yum -y install mysql mysql-server mysql-devel wget ...
  • spark系列18:sparksql操作hive表的使用

    千次阅读 2021-03-18 21:41:55
    1.SparkSQL 整合 Hive 导读 开启Hive的MetaStore独立进程 整合SparkSQL和Hive的MetaStore 和一个文件格式不同,Hive是一个外部的数据存储和查询引擎, 所以如果Spark要访问Hive的话, 就需要先整合Hive ...
  • Hive的安装(超详细)

    千次阅读 2021-11-23 12:08:00
    Hive的安装模式 嵌入模式:使用内嵌的 Derby数据库存储元数据,这种方式是Hive的默认安装方式,配置简单,但是一次只能连接一个客户端,适合用来测试,不适合生产环境。 本地模式:采用外部数据库存储元数据,该模式...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 359,215
精华内容 143,686
关键字:

hive

友情链接: 新建文件夹.rar