Hive的基本介绍

1、hive产生的原因

· a) 方便对文件及数据的元数据进行管理，提供统一的元数据管理方式
b) 提供更加简单的方式来访问大规模的数据集，使用SQL语言进行数据分析

2、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经常被大数据企业用作企业级数据仓库。
Hive在使用过程中是使用SQL语句来进行数据分析，由SQL语句到具体的任务执行还需要经过解释器，编译器，优化器，执行器四部分才能完成。
（1）解释器：调用语法解释器和语义分析器将SQL语句转换成对应的可执行的java代码或者业务代码
（2）编译器：将对应的java代码转换成字节码文件或者jar包
（3）优化器：从SQL语句到java代码的解析转化过程中需要调用优化器，进行相关策略的优化，实现最优的 查询性能
（4）执行器：当业务代码转换完成之后，需要上传到MapReduce的集群中执行

3、数据仓库—Hive（简单了解即可）

1、数据仓库基本概念

    数据仓库，英文名称为Data Warehouse，可简写为DW或DWH。数据仓库，是为企业所有级别的决策制定过程，提供所有类型数据支持的战略集合。它是单个数据存储，出于分析性报告和决策支持目的而创建。 为需要业务智能的企业，提供指导业务流程改进、监视时间、成本、质量以及控制。

2、数据处理分类：OLAP与OLTP

    数据处理大致可以分成两大类：联机事务处理OLTP（on-line transaction processing）、联机分析处理OLAP（On-Line Analytical Processing）。OLTP是传统的关系型数据库的主要应用，主要是基本的、日常的事务处理，例如银行交易。OLAP是数据仓库系统的主要应用，支持复杂的分析操作，侧重决策支持，并且提供直观易懂的查询结果。

3、OLTP

    OLTP，也叫联机事务处理（Online Transaction Processing），表示事务性非常高的系统，一般都是高可用的在线系统，以小的事务以及小的查询为主，评估其系统的时候，一般看其每秒执行的Transaction以及Execute SQL的数量。在这样的系统中，单个数据库每秒处理的Transaction往往超过几百个，或者是几千个，Select 语句的执行量每秒几千甚至几万个。典型的OLTP系统有电子商务系统、银行、证券等，如美国eBay的业务数据库，就是很典型的OLTP数据库。

4、OLAP

    OLAP（On-Line Analysis Processing）在线分析处理是一种共享多维信息的快速分析技术；OLAP利用多维数据库技术使用户从不同角度观察数据；OLAP用于支持复杂的分析操作，侧重于对管理人员的决策支持，可以满足分析人员快速、灵活地进行大数据复量的复杂查询的要求，并且以一种直观、易懂的形式呈现查询结果，辅助决策。

基本概念：

        度量：数据度量的指标，数据的实际含义            维度：描述与业务主题相关的一组属性            事实：不同维度在某一取值下的度量

特点：

        (1)快速性：用户对OLAP的快速反应能力有很高的要求。系统应能在5秒内对用户的大部分分析要求做出反                                应。            (2)可分析性：OLAP系统应能处理与应用有关的任何逻辑分析和统计分析。<br />            (3)多维性：多维性是OLAP的关键属性。系统必须提供对数据的多维视图和分析,包括对层次维和多重层次                                维的完全支持。            (4)信息性：不论数据量有多大，也不管数据存储在何处，OLAP系统应能及时获得信息，并且管理大容量信                                息。

分类：

        按照存储方式分类：<br />                    ROLAP：关系型在线分析处理<br />                    MOLAP：多维在线分析处理<br />                    HOLAP：混合型在线分析处理<br />            按照处理方式分类：<br />                    Server OLAP和Client OLAP

操作：

钻取：在维的不同层次间的变化，从上层降到下一层，或者说将汇总数据拆分到更细节的数据，比如通过对2019年第二季度的总销售数据进行钻取来查看2019年4,5,6,每个月的消费数据，再例如可以钻取浙江省来查看杭州市、温州市、宁波市......这些城市的销售数据            <br />       上卷：钻取的逆操作，即从细粒度数据向更高汇总层的聚合，如将江苏省、上海市、浙江省的销售数据进行汇总来查看江浙沪地区的销售数据            <br />      切片：选择维中特定的值进行分析，比如只选择电子产品的销售数据或者2019年第二季度的数据            <br />      切块：选择维中特定区间的数据或者某批特定值进行分析，比如选择2019年第一季度到第二季度的销售数据或者是电子产品和日用品的销售数据            <br />      旋转：维的位置互换，就像是二维表的行列转换，比如通过旋转来实现产品维和地域维的互换        

4、数据库与数据仓库的区别

    **注意：前三条重点掌握理解，后面的了解即可**                <br />        1、数据库是对业务系统的支撑，性能要求高，相应的时间短，而数据仓库则对响应时间没有太多的要求，当然也是越快越好<br />        2、数据库存储的是某一个产品线或者某个业务线的数据，数据仓库可以将多个数据源的数据经过统一的规则清洗之后进行集中统一管理<br />        3、数据库中存储的数据可以修改，无法保存各个历史时刻的数据，数据仓库可以保存各个时间点的数据，形成时间拉链表，可以对各个历史时刻的数据做分析<br />        4、数据库一次操作的数据量小，数据仓库操作的数据量大<br />        5、数据库使用的是实体-关系（E-R）模型，数据仓库使用的是星型模型或者雪花模型<br />        6、数据库是面向事务级别的操作，数据仓库是面向分析的操作

Hive的架构

1、Hive的架构图

2、Hive的服务（角色）

1、用户访问接口

    CLI（Command Line Interface）：用户可以使用Hive自带的命令行接口执行Hive QL、设置参数等功能<br />        JDBC/ODBC：用户可以使用JDBC或者ODBC的方式在代码中操作Hive<br />        Web GUI：浏览器接口，用户可以在浏览器中对Hive进行操作（2.2之后淘汰）

2、Thrift Server:

    Thrift服务运行客户端使用Java、C++、Ruby等多种语言，通过编程的方式远程访问Hive

3、Driver

    Hive Driver是Hive的核心，其中包含解释器、编译器、优化器等各个组件，完成从SQL语句到MapReduce任务的解析优化执行过程

4、metastore

Hive的元数据存储服务，一般将数据存储在关系型数据库中，为了实现Hive元数据的持久化操作，Hive的安装包中自带了Derby内存数据库，但是在实际的生产环境中一般使用mysql来存储元数据    <br />**未完待续。。。。。。。**            

3、Hive的访问流程图

Hive的安装搭建

Hive可以从源码中编译安装，也可以直接使用官网下载的安装包，在此处我们选择安装包解压安装的方式。
Hive中最最重要的角色就是metastore
因此按照metastore的管理共有四种hive的安装搭建方式：官网参考地址如下：
https://cwiki.apache.org/confluence/display/Hive/AdminManual+Metastore+Administration

Hive安装分类：

1、Local/Embedded Metastore Database（Derby）<br />    2、Remote Metastore Database<br />    3、Local/Embedded Metastore Server<br />    4、Remote Metastore Server<br />    根据上述分类，可以简单归纳为以下三类<br />    1、使用Hive自带的内存数据库Derby作为元数据存储<br />    2、使用远程数据库mysql作为元数据存储<br />    3、使用本地/远程元数据服务模式安装Hive

详细操作：

1、使用Hive自带的内存数据库Derby作为元数据存储

2、使用远程数据库mysql作为元数据存储

3、使用本地/远程元数据服务模式安装Hive （企业最常用）

Hive远程数据库模式安装 (node02)

安装hive的步骤：

1、解压安装

2、修改环境变量

        vi /etc/profile
        export HIVE_HOME=/opt/bigdata/hive-2.3.4
        将bin目录添加到PATH路径中

3、修改配置文件，进入到/opt/bigdata/hive-2.3.4/conf

    //修改文件名称，必须修改，文件名称必须是hive-site.xml
        mv hive-default.xml.template hive-site.xml
    //增加配置：
            进入到文件之后，将文件原有的配置删除，但是保留最后一行，
            从<configuration></configuration>，将光标移动到<configuration>这一行，
            在vi的末行模式中输入以下命令
            :.,$-1d
    //增加如下配置信息：
            <property>
                <name>hive.metastore.warehouse.dir</name>
                <value>/var/bigdata/hive/warehouse</value>
            </property>
            <property>
                <name>javax.jdo.option.ConnectionURL</name>
                <value>jdbc:mysql://node01:3306/hive?createDatabaseIfNotExist=true</value>
            </property>
            <property>
                <name>javax.jdo.option.ConnectionDriverName</name>
                <value>com.mysql.cj.jdbc.Driver</value>
            </property>
            <property>
                <name>javax.jdo.option.ConnectionUserName</name>
                <value>root</value>
            </property>
            <property>
                <name>javax.jdo.option.ConnectionPassword</name>
                <value>root</value>
            </property>

4、添加MySQL的驱动包拷贝到lib目录

5、执行初始化元数据数据库的步骤

        schematool -dbType mysql -initSchema

6、执行hive启动对应的服务

hive

7、执行相应的hive SQL的基本操作

show databases;
create table tb(int age,height int);
在hdfs 中创建/var/bigdata/hive/warehouse/tb
desc tb; 查看表结构
desc formatted tb; 查看表详细信息
insert into tb values (1,23) //执行mapreduce任务
/var/bigdata/hive/warehouse/tb/000000_0 只有map
数据如下
1^A23
在VI编辑器才能看到^A这个分隔符，cat看不到
^A需要通过ctrl+v+a打出来

hive远程元数据服务模式安装

1、选择两台虚拟机，node03作为服务端，node04作为客户端

2、分别在Node03和node04上解压hive的安装包，或者在从node02上远程拷贝hive的安装包到Node03和node04

3、node03修改hive-site.xml配置：

    <property>
        <name>hive.metastore.warehouse.dir</name>
        <value>/var/bigdata/hive_remote/warehouse</value>
    </property>
    <property>
        <name>javax.jdo.option.ConnectionURL</name>
        <value>jdbc:mysql://node01:3306/hive_remote?createDatabaseIfNotExist=true</value>
    </property>
    <property>
        <name>javax.jdo.option.ConnectionDriverName</name>
        <value>com.mysql.jdbc.Driver</value>
    </property>
    <property>
        <name>javax.jdo.option.ConnectionUserName</name>
        <value>root</value>
    </property>
    <property>
        <name>javax.jdo.option.ConnectionPassword</name>
        <value>root</value>
    </property>

4、node04修改hive-site.xml配置：

    <property>
        <name>hive.metastore.warehouse.dir</name>
        <value>/var/bigdata/hive_remote/warehouse</value>
    </property>
    <property>
        <name>hive.metastore.uris</name>
        <value>thrift://node03:9083</value>
    </property>

5、在node03服务端执行元数据库的初始化操作，schematool -dbType mysql -initSchema

6、在node03上执行hive —service metastore,启动hive的元数据服务，是阻塞式窗口

7、在node04上执行hive，进入到hive的cli窗口

Hive基本SQL操作

Hive DDL（数据库定义语言）

1、数据库的基本操作

--展示所有数据库
    show databases;
--切换数据库
    use database_name;
/*创建数据库        
    CREATE (DATABASE|SCHEMA) [IF NOT EXISTS] database_name
      [COMMENT database_comment]
      [LOCATION hdfs_path]
      [WITH DBPROPERTIES (property_name=property_value, ...)];
*/
    create database test;
/*
    删除数据库    
    DROP (DATABASE|SCHEMA) [IF EXISTS] database_name [RESTRICT|CASCADE];    
*/
    drop database database_name;

注意：当进入hive的命令行开始编写SQL语句的时候，如果没有任何相关的数据库操作，那么默认情况下，所有的表存在于default数据库，在hdfs上的展示形式是将此数据库的表保存在hive的默认路径下，如果创建了数据库，那么会在hive的默认路径下生成一个database_name.db的文件夹，此数据库的所有表会保存在database_name.db的目录下。

2、数据库表的基本操作

/*
    创建表的操作
        基本语法：
        CREATE [TEMPORARY] [EXTERNAL] TABLE [IF NOT EXISTS] [db_name.]table_name    --             (Note: TEMPORARY available in Hive 0.14.0 and later)
          [(col_name data_type [COMMENT col_comment], ... [constraint_specification])]
          [COMMENT table_comment]
          [PARTITIONED BY (col_name data_type [COMMENT col_comment], ...)]
          [CLUSTERED BY (col_name, col_name, ...) [SORTED BY (col_name [ASC|DESC], ...)]                 INTO num_buckets BUCKETS]
          [SKEWED BY (col_name, col_name, ...)                  -- (Note: Available in Hive             0.10.0 and later)]
         ON ((col_value, col_value, ...), (col_value, col_value, ...), ...)
         [STORED AS DIRECTORIES]
          [
               [ROW FORMAT row_format] 
               [STORED AS file_format]
             | STORED BY 'storage.handler.class.name' [WITH SERDEPROPERTIES (...)]  --                 (Note: Available in Hive 0.6.0 and later)
          ]
          [LOCATION hdfs_path]
          [TBLPROPERTIES (property_name=property_value, ...)]   -- (Note: Available in Hive             0.6.0 and later)
          [AS select_statement];   -- (Note: Available in Hive 0.5.0 and later; not                     supported for external tables)
        CREATE [TEMPORARY] [EXTERNAL] TABLE [IF NOT EXISTS] [db_name.]table_name
              LIKE existing_table_or_view_name
          [LOCATION hdfs_path];
         复杂数据类型
        data_type
           : primitive_type
           | array_type
           | map_type
           | struct_type
           | union_type  -- (Note: Available in Hive 0.7.0 and later)
         基本数据类型
        primitive_type
          : TINYINT
          | SMALLINT
          | INT
          | BIGINT
          | BOOLEAN
          | FLOAT
          | DOUBLE
           | DOUBLE PRECISION -- (Note: Available in Hive 2.2.0 and later)
          | STRING
          | BINARY      -- (Note: Available in Hive 0.8.0 and later)
          | TIMESTAMP   -- (Note: Available in Hive 0.8.0 and later)
          | DECIMAL     -- (Note: Available in Hive 0.11.0 and later)
          | DECIMAL(precision, scale)  -- (Note: Available in Hive 0.13.0 and later)
          | DATE        -- (Note: Available in Hive 0.12.0 and later)
          | VARCHAR     -- (Note: Available in Hive 0.12.0 and later)
          | CHAR        -- (Note: Available in Hive 0.13.0 and later)
        array_type
          : ARRAY < data_type >
        map_type
          : MAP < primitive_type, data_type >
        struct_type
          : STRUCT < col_name : data_type [COMMENT col_comment], ...>
        union_type
           : UNIONTYPE < data_type, data_type, ... >  -- (Note: Available in Hive 0.7.0 and             later)
         行格式规范
        row_format
          : DELIMITED [FIELDS TERMINATED BY char [ESCAPED BY char]] [COLLECTION ITEMS                 TERMINATED BY char]
            [MAP KEYS TERMINATED BY char] [LINES TERMINATED BY char]
           [NULL DEFINED AS char]   -- (Note: Available in Hive 0.13 and later)
              | SERDE serde_name [WITH SERDEPROPERTIES (property_name=property_value,                 property_name=property_value, ...)]
         文件基本类型
        file_format:
          : SEQUENCEFILE
          | TEXTFILE    -- (Default, depending on hive.default.fileformat configuration)
          | RCFILE      -- (Note: Available in Hive 0.6.0 and later)
          | ORC         -- (Note: Available in Hive 0.11.0 and later)
          | PARQUET     -- (Note: Available in Hive 0.13.0 and later)
          | AVRO        -- (Note: Available in Hive 0.14.0 and later)
          | JSONFILE    -- (Note: Available in Hive 4.0.0 and later)
          | INPUTFORMAT input_format_classname OUTPUTFORMAT output_format_classname
         表约束
        constraint_specification:
          : [, PRIMARY KEY (col_name, ...) DISABLE NOVALIDATE ]
            [, CONSTRAINT constraint_name FOREIGN KEY (col_name, ...) REFERENCES                     table_name(col_name, ...) DISABLE NOVALIDATE 
*/
--创建普通hive表（不包含行定义格式）
    create table psn
    (
    id int,
    name string,
    likes array<string>,
    address map<string,string>
    )
--创建自定义行格式的hive表
    create table psn2
    (
    id int,
    name string,
    likes array<string>,
    address map<string,string>
    )
    row format delimited
    fields terminated by ','
    collection items terminated by '-'
    map keys terminated by ':';
    LINES TERMINATED 目前仅支持\n,需要重写inputformat才可以
--创建默认分隔符的hive表（^A、^B、^C）
    create table psn3
    (
    id int,
    name string,
    likes array<string>,
    address map<string,string>
    )
    row format delimited
    fields terminated by '\001'
    collection items terminated by '\002'
    map keys terminated by '\003';
    --或者
    create table psn3
    (
    id int,
    name string,
    likes array<string>,
    address map<string,string>
    )
--创建hive的外部表(需要添加external和location的关键字)
    create external table psn4
    (
    id int,
    name string,
    likes array<string>,
    address map<string,string>
    )
    row format delimited
    fields terminated by ','
    collection items terminated by '-'
    map keys terminated by ':'
    location '/data';
/*
    在之前创建的表都属于hive的内部表（psn,psn2,psn3）,而psn4属于hive的外部表，
    内部表跟外部表的区别：
        1、hive内部表创建的时候数据存储在hive的默认存储目录中，外部表在创建的时候需要制定额外的目录
        2、hive内部表删除的时候，会将元数据和数据都删除，而外部表只会删除元数据，不会删除数据
    应用场景:
        内部表:需要先创建表，然后向表中添加数据，适合做中间表的存储
        外部表：可以先创建表，再添加数据，也可以先有数据，再创建表，本质上是将hdfs的某一个目录的数据跟                hive的表关联映射起来，因此适合原始数据的存储，不会因为误操作将数据给删除掉
*/    
/*
    hive的分区表:
        hive默认将表的数据保存在某一个hdfs的存储目录下，当需要检索符合条件的某一部分数据的时候，需要全量遍历数据，io量比较大，效率比较低，因此可以采用分而治之的思想，将符合某些条件的数据放置在某一个目录，此时检索的时候只需要搜索指定目录即可，不需要全量遍历数据。
*/
--创建单分区表
    create table psn5
    (
    id int,
    name string,
    likes array<string>,
    address map<string,string>
    )
    partitioned by(gender string)
    row format delimited
    fields terminated by ','
    collection items terminated by '-'
    map keys terminated by ':';
--创建多分区表
    create table psn6
    (
    id int,
    name string,
    likes array<string>,
    address map<string,string>
    )
    partitioned by(gender string,age int)
    row format delimited
    fields terminated by ','
    collection items terminated by '-'
    map keys terminated by ':';    
/*
    注意：
        1、当创建完分区表之后，在保存数据的时候，会在hdfs目录中看到分区列会成为一个目录，以多级目录的形式存在
        2、当创建多分区表之后，插入数据的时候不可以只添加一个分区列，需要将所有的分区列都添加值
        3、多分区表在添加分区列的值得时候，与顺序无关，与分区表的分区列的名称相关，按照名称就行匹配
*/    
--给分区表添加分区列的值
    alter table table_name add partition(col_name=col_value)
--删除分区列的值
    alter table table_name drop partition(col_name=col_value)
/*
    注意:
        1、添加分区列的值的时候，如果定义的是多分区表，那么必须给所有的分区列都赋值
        2、删除分区列的值的时候，无论是单分区表还是多分区表，都可以将指定的分区进行删除,级联删除
*/
/*
    修复分区:
        在使用hive外部表的时候，可以先将数据上传到hdfs的某一个目录中，然后再创建外部表建立映射关系，如果在上传数据的时候，参考分区表的形式也创建了多级目录，那么此时创建完表之后，是查询不到数据的，原因是分区的元数据没有保存在mysql中，因此需要修复分区，将元数据同步更新到mysql中，此时才可以查询到元数据。具体操作如下：
*/    
--在hdfs创建目录并上传文件
    hdfs dfs -mkdir /msb
    hdfs dfs -mkdir /msb/age=10
    hdfs dfs -mkdir /msb/age=20
    hdfs dfs -put /root/data/data /msb/age=10
    hdfs dfs -put /root/data/data /msb/age=20
--创建外部表
    create external table psn7
    (
    id int,
    name string,
    likes array<string>,
    address map<string,string>
    )
    partitioned by(age int)
    row format delimited
    fields terminated by ','
    collection items terminated by '-'
    map keys terminated by ':'
    location '/msb';
--查询结果（没有数据）
    select * from psn7;
--修复分区
    msck repair table psn7;
--查询结果（有数据）
    select * from psn7;
/*
    问题：
        以上面的方式创建hive的分区表会存在问题，每次插入的数据都是人为指定分区列的值，我们更加希望能够根          据记录中的某一个字段来判断将数据插入到哪一个分区目录下，此时利用我们上面的分区方式是无法完成操作            的，需要使用动态分区来完成相关操作，现在学的知识点无法满足，后续讲解。
*/

Hive DML

数据准备

1,小明1,lol-book-movie,beijing:mashibing-shanghai:pudong
2,小明2,lol-book-movie,beijing:mashibing-shanghai:pudong
3,小明3,lol-book-movie,beijing:mashibing-shanghai:pudong
4,小明4,lol-book-movie,beijing:mashibing-shanghai:pudong
5,小明5,lol-movie,beijing:mashibing-shanghai:pudong
6,小明6,lol-book-movie,beijing:mashibing-shanghai:pudong
7,小明7,lol-book,beijing:mashibing-shanghai:pudong
8,小明8,lol-book,beijing:mashibing-shanghai:pudong
9,小明9,lol-book-movie,beijing:mashibing-shanghai:pudong

1、插入数据

1、Loading files into tables

/*
    记载数据文件到某一张表中
    语法：
        LOAD DATA [LOCAL] INPATH 'filepath' [OVERWRITE] INTO TABLE tablename [PARTITION         (partcol1=val1, partcol2=val2 ...)]
        LOAD DATA [LOCAL] INPATH 'filepath' [OVERWRITE] INTO TABLE tablename [PARTITION         (partcol1=val1, partcol2=val2 ...)] [INPUTFORMAT 'inputformat' SERDE 'serde']             (3.0 or later)
*/
--加载本地数据到hive表
    load data local inpath '/root/data/data' into table psn;--(/root/data/data指的是本地        linux目录)
--加载hdfs数据文件到hive表
    load data inpath '/data/data' into table psn;--(/data/data指的是hdfs的目录)
/*
    注意：
        1、load操作不会对数据做任何的转换修改操作
        2、从本地linux load数据文件是复制文件的过程
        3、从hdfs load数据文件是移动文件的过程
        4、load操作也支持向分区表中load数据，只不过需要添加分区列的值
        load本质是复制或移动文件到hdfs  直接hdfs dfs -put 也行，前提数据类型要一致，数据类型不一致，上传也能成功，但读取会有null
*/
/*
If the OVERWRITE keyword is used then the contents of the target table (or partition) will be deleted and replaced by the files referred to by filepath; otherwise the files referred by filepath will be added to the table.
*/

2、Inserting data into Hive Tables from queries

/*
    从查询语句中获取数据插入某张表
    语法：
        Standard syntax:
        INSERT OVERWRITE TABLE tablename1 [PARTITION (partcol1=val1, partcol2=val2 ...)             [IF NOT EXISTS]] select_statement1 FROM from_statement;
        INSERT INTO TABLE tablename1 [PARTITION (partcol1=val1, partcol2=val2 ...)]                 select_statement1 FROM from_statement;
        Hive extension (multiple inserts):
        FROM from_statement
        INSERT OVERWRITE TABLE tablename1 [PARTITION (partcol1=val1, partcol2=val2 ...)             [IF NOT EXISTS]] select_statement1
        [INSERT OVERWRITE TABLE tablename2 [PARTITION ... [IF NOT EXISTS]]                             select_statement2]
        [INSERT INTO TABLE tablename2 [PARTITION ...] select_statement2] ...;
            FROM from_statement
        INSERT INTO TABLE tablename1 [PARTITION (partcol1=val1, partcol2=val2 ...)]                 select_statement1
        [INSERT INTO TABLE tablename2 [PARTITION ...] select_statement2]
        [INSERT OVERWRITE TABLE tablename2 [PARTITION ... [IF NOT EXISTS]]                             select_statement2] ...;
        Hive extension (dynamic partition inserts):
            INSERT OVERWRITE TABLE tablename PARTITION (partcol1[=val1], partcol2[=val2]                 ...) select_statement FROM from_statement;
            INSERT INTO TABLE tablename PARTITION (partcol1[=val1], partcol2[=val2] ...)                 select_statement FROM from_statement;
*/
--注意：这种方式插入数据的时候需要预先创建好结果表
--从表中查询数据插入结果表
    INSERT OVERWRITE TABLE psn9 SELECT id,name FROM psn
--从表中获取部分列插入到新表中
    from psn
    insert overwrite table psn9
    select id,name 
    insert into table psn10
    select id

3、Writing data into the filesystem from queries

/*
    将查询到的结果插入到文件系统中
    语法：    
    Standard syntax:
        INSERT OVERWRITE [LOCAL] DIRECTORY directory1
          [ROW FORMAT row_format] [STORED AS file_format] (Note: Only available starting             with Hive 0.11.0)
          SELECT ... FROM ...
    Hive extension (multiple inserts):
        FROM from_statement
        INSERT OVERWRITE [LOCAL] DIRECTORY directory1 select_statement1
        [INSERT OVERWRITE [LOCAL] DIRECTORY directory2 select_statement2] ... 
        row_format
          : DELIMITED [FIELDS TERMINATED BY char [ESCAPED BY char]] [COLLECTION ITEMS             TERMINATED BY char]
        [MAP KEYS TERMINATED BY char] [LINES TERMINATED BY char]
        [NULL DEFINED AS char] (Note: Only available starting with Hive 0.13)
*/
--注意：路径千万不要填写根目录，会把所有的数据文件都覆盖
--将查询到的结果导入到hdfs文件系统中
    insert overwrite directory '/result' select * from psn;
--将查询的结果导入到本地文件系统中
    insert overwrite local directory '/result' select * from psn;

4、Inserting values into tables from SQL

/*
    使用传统关系型数据库的方式插入数据，效率较低
    语法：
    Standard Syntax:
        INSERT INTO TABLE tablename [PARTITION (partcol1[=val1], partcol2[=val2] ...)]             VALUES values_row [, values_row ...]
    Where values_row is:
        ( value [, value ...] )
        where a value is either null or any valid SQL literal
*/
--插入数据
    insert into psn values(1,'zhangsan')

2、数据更新和删除

在官网中我们明确看到hive中是支持Update和Delete操作的，但是实际上，是需要事务的支持的，Hive对于事务的支持有很多的限制，如下图所示：

因此，在使用hive的过程中，我们一般不会产生删除和更新的操作，如果你需要测试的话，参考下面如下配置：

//在hive的hive-site.xml中添加如下配置：
    <property>
        <name>hive.support.concurrency</name>
        <value>true</value>
    </property>
    <property>
        <name>hive.enforce.bucketing</name>
        <value>true</value>
    </property>
    <property>
        <name>hive.exec.dynamic.partition.mode</name>
        <value>nonstrict</value>
    </property>
    <property>
        <name>hive.txn.manager</name>
        <value>org.apache.hadoop.hive.ql.lockmgr.DbTxnManager</value>
    </property>
    <property>
        <name>hive.compactor.initiator.on</name>
        <value>true</value>
    </property>
    <property>
        <name>hive.compactor.worker.threads</name>
        <value>1</value>
    </property>
//操作语句
    create table test_trancaction (user_id Int,name String) clustered by (user_id) into 3             buckets stored as orc TBLPROPERTIES ('transactional'='true');
    create table test_insert_test(id int,name string) row format delimited fields                   TERMINATED BY ',';
    insert into test_trancaction select * from test_insert_test;
    update test_trancaction set name='jerrick_up' where id=1;
//数据文件
    1,jerrick
    2,tom
    3,jerry
    4,lily
    5,hanmei
    6,limlei
    7,lucky

Hive Serde

目的：

Hive Serde用来做序列化和反序列化，构建在数据存储和执行引擎之间，对两者实现解耦。

应用场景：

1、hive主要用来存储结构化数据，如果结构化数据存储的格式嵌套比较复杂的时候，可以使用serde的方式，利用正则表达式匹配的方法来读取数据，例如，表字段如下：id,name,map<string,array<map<string,string>>>
2、当读取数据的时候，数据的某些特殊格式不希望显示在数据中，如：

192.168.57.4 - - [29/Feb/2019:18:14:35 +0800] “GET /bg-upper.png HTTP/1.1” 304 -

不希望数据显示的时候包含[]或者””,此时可以考虑使用serde的方式

语法规则：

        row_format
        : DELIMITED 
          [FIELDS TERMINATED BY char [ESCAPED BY char]] 
          [COLLECTION ITEMS TERMINATED BY char] 
          [MAP KEYS TERMINATED BY char] 
          [LINES TERMINATED BY char] 
        : SERDE serde_name [WITH SERDEPROPERTIES (property_name=property_value,                                                     property_name=property_value, ...)]

应用案例：

1、数据文件

192.168.57.4 - - [29/Feb/2019:18:14:35 +0800] "GET /bg-upper.png HTTP/1.1" 304 -
192.168.57.4 - - [29/Feb/2019:18:14:35 +0800] "GET /bg-nav.png HTTP/1.1" 304 -
192.168.57.4 - - [29/Feb/2019:18:14:35 +0800] "GET /asf-logo.png HTTP/1.1" 304 -
192.168.57.4 - - [29/Feb/2019:18:14:35 +0800] "GET /bg-button.png HTTP/1.1" 304 -
192.168.57.4 - - [29/Feb/2019:18:14:35 +0800] "GET /bg-middle.png HTTP/1.1" 304 -
192.168.57.4 - - [29/Feb/2019:18:14:36 +0800] "GET / HTTP/1.1" 200 11217
192.168.57.4 - - [29/Feb/2019:18:14:36 +0800] "GET / HTTP/1.1" 200 11217
192.168.57.4 - - [29/Feb/2019:18:14:36 +0800] "GET /tomcat.css HTTP/1.1" 304 -
192.168.57.4 - - [29/Feb/2019:18:14:36 +0800] "GET /tomcat.png HTTP/1.1" 304 -
192.168.57.4 - - [29/Feb/2019:18:14:36 +0800] "GET /asf-logo.png HTTP/1.1" 304 -
192.168.57.4 - - [29/Feb/2019:18:14:36 +0800] "GET /bg-middle.png HTTP/1.1" 304 -
192.168.57.4 - - [29/Feb/2019:18:14:36 +0800] "GET /bg-button.png HTTP/1.1" 304 -
192.168.57.4 - - [29/Feb/2019:18:14:36 +0800] "GET /bg-nav.png HTTP/1.1" 304 -
192.168.57.4 - - [29/Feb/2019:18:14:36 +0800] "GET /bg-upper.png HTTP/1.1" 304 -
192.168.57.4 - - [29/Feb/2019:18:14:36 +0800] "GET / HTTP/1.1" 200 11217
192.168.57.4 - - [29/Feb/2019:18:14:36 +0800] "GET /tomcat.css HTTP/1.1" 304 -
192.168.57.4 - - [29/Feb/2019:18:14:36 +0800] "GET /tomcat.png HTTP/1.1" 304 -
192.168.57.4 - - [29/Feb/2019:18:14:36 +0800] "GET / HTTP/1.1" 200 11217
192.168.57.4 - - [29/Feb/2019:18:14:36 +0800] "GET /tomcat.css HTTP/1.1" 304 -
192.168.57.4 - - [29/Feb/2019:18:14:36 +0800] "GET /tomcat.png HTTP/1.1" 304 -
192.168.57.4 - - [29/Feb/2019:18:14:36 +0800] "GET /bg-button.png HTTP/1.1" 304 -
192.168.57.4 - - [29/Feb/2019:18:14:36 +0800] "GET /bg-upper.png HTTP/1.1" 304 -

2、基本操作：

--创建表
    CREATE TABLE logtbl (
        host STRING,
        identity STRING,
        t_user STRING,
        time STRING,
        request STRING,
        referer STRING,
        agent STRING)
      ROW FORMAT SERDE 'org.apache.hadoop.hive.serde2.RegexSerDe'
      WITH SERDEPROPERTIES (
        "input.regex" = "([^ ]*) ([^ ]*) ([^ ]*) \\[(.*)\\] \"(.*)\" (-|[0-9]*) (-|[0-        9]*)"
      )
  STORED AS TEXTFILE;
--加载数据
    load data local inpath '/root/data/log' into table logtbl;
--查询操作
    select * from logtbl;
--数据显示如下（不包含[]和"）
192.168.57.4    -    -    29/Feb/2019:18:14:35 +0800    GET /bg-upper.png HTTP/1.1    304    -
192.168.57.4    -    -    29/Feb/2019:18:14:35 +0800    GET /bg-nav.png HTTP/1.1    304    -
192.168.57.4    -    -    29/Feb/2019:18:14:35 +0800    GET /asf-logo.png HTTP/1.1    304    -
192.168.57.4    -    -    29/Feb/2019:18:14:35 +0800    GET /bg-button.png HTTP/1.1    304    -
192.168.57.4    -    -    29/Feb/2019:18:14:35 +0800    GET /bg-middle.png HTTP/1.1    304    -

HiveServer2

基本概念介绍

1、HiveServer2基本介绍

HiveServer2 (HS2) is a server interface that enables remote clients to execute queries against Hive and retrieve the results (a more detailed intro here). The current implementation, based on Thrift RPC, is an improved version of HiveServer and supports multi-client concurrency and authentication. It is designed to provide better support for open API clients like JDBC and ODBC.

 HiveServer2是一个服务接口，能够允许远程的客户端去执行SQL请求且得到检索结果。HiveServer2的实现，依托于Thrift RPC，是HiveServer的提高版本，它被设计用来提供更好的支持对于open API例如JDBC和ODBC。

HiveServer is an optional service that allows a remote client to submit requests to Hive, using a variety of programming languages, and retrieve results. HiveServer is built on Apache ThriftTM (http://thrift.apache.org/), therefore it is sometimes called the Thrift server although this can lead to confusion because a newer service named HiveServer2 is also built on Thrift. Since the introduction of HiveServer2, HiveServer has also been called HiveServer1.

HiveServer是一个可选的服务，只允许一个远程的客户端去提交请求到hive中。（目前已被淘汰）

2、Beeline

HiveServer2 supports a command shell Beeline that works with HiveServer2. It's a JDBC client that is based on the SQLLine CLI 。
HiveServer2提供了一种新的命令行接口，可以提交执行SQL语句。

hiveserver2的搭建使用

在搭建hiveserver2服务的时候需要修改hdfs的超级用户的管理权限，修改配置如下：

--在hdfs集群的core-site.xml文件中添加如下配置文件   启动namenode是哪个用户root就改成哪一个
    <property>
        <name>hadoop.proxyuser.root.groups</name>    
        <value>*</value>
    </property>
    <property>
        <name>hadoop.proxyuser.root.hosts</name>    
        <value>*</value>
    </property>
--配置完成之后重新启动集群，或者在namenode的节点上执行如下命令
    hdfs dfsadmin -fs hdfs://node01:8020 -refreshSuperUserGroupsConfiguration   //node01执行
    hdfs dfsadmin -fs hdfs://node02:8020 -refreshSuperUserGroupsConfiguration  //node02执行
    yarn rmadmin -fs hdfs://node01:8020 -refreshSuperUserGroupsConfiguration   //rm上执行
    yarn rmadmin -fs hdfs://node02:8020 -refreshSuperUserGroupsConfiguration   //rm上执行

1、独立hiveserver2模式

1、将现有的所有hive的服务停止，不需要修改任何服务，在node03机器上执行hiveserver2或者hive --service hiveserver2的命令，开始启动hiveserver2的服务，hiveserver2的服务也是一个阻塞式窗口，当开启服务后，会开启一个10000的端口，对外提供服务。(hiveserver2直接访问mysql)
2、在node04上使用beeline的方式进行登录

2、共享metastore server的hiveserver2模式搭建 (推荐此模式)

1、在node03上执行hive --service metastore启动元数据服务
2、在node04上执行hiveserver2或者hive --service hiveserver2两个命令其中一个都可以
3、在任意一台包含beeline脚本的虚拟机中执行beeline的命令进行连接

HiveServer2的访问方式

1、beeline的访问方式

（1）beeline -u jdbc:hive2://<host>:<port>/<db> -n name
（2）beeline进入到beeline的命令行<br />                beeline> !connect jdbc:hive2://<host>:<port>/<db>  root 123
    注意：
        1、使用beeline方式登录的时候，默认的用户名和密码是不验证的，也就是说随便写用户名和密码即可
        2、使用第一种beeline的方式访问的时候，用户名和密码可以不输入
        3、使用第二种beeline方式访问的时候，必须输入用户名和密码，用户名和密码是什么无所谓

2、jdbc的访问方式

1、创建普通的java项目，将hive的jar包添加到classpath中，最精简的jar包如下：

commons-lang-2.6.jar
commons-logging-1.2.jar
curator-client-2.7.1.jar
curator-framework-2.7.1.jar
guava-14.0.1.jar
hive-exec-2.3.4.jar
hive-jdbc-2.3.4.jar
hive-jdbc-handler-2.3.4.jar
hive-metastore-2.3.4.jar
hive-service-2.3.4.jar
hive-service-rpc-2.3.4.jar
httpclient-4.4.jar
httpcore-4.4.jar
libfb303-0.9.3.jar
libthrift-0.9.3.jar
log4j-1.2-api-2.6.2.jar
log4j-api-2.6.2.jar
log4j-core-2.6.2.jar
log4j-jul-2.5.jar
log4j-slf4j-impl-2.6.2.jar
log4j-web-2.6.2.jar
zookeeper-3.4.6.jar

2、编辑如下代码：

package com.mashibing;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
public class HiveJdbcClient {
    private static String driverName = "org.apache.hive.jdbc.HiveDriver";
    public static void main(String[] args) throws SQLException {
        try {
            Class.forName(driverName);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        Connection conn = DriverManager.getConnection("jdbc:hive2://node04:10000/default", "root", "");
        Statement stmt = conn.createStatement();
        String sql = "select * from psn limit 5";
        ResultSet res = stmt.executeQuery(sql);
        while (res.next()) {
            System.out.println(res.getString(1) + "-" + res.getString("name"));
        }
    }
}

运行之后，即可得到最终结果。

Hive函数

Hive中提供了非常丰富的运算符和内置函数支撑，具体操作如下：

1.内置运算符

1.1关系运算符

1.2算术运算符

1.3逻辑运算符

1.4复杂类型函数

1.5对复杂类型函数操作

2.内置函数

2.1数学函数

2.2收集函数

2.3类型转换函数

2.4日期函数

2.5条件函数

2.6字符函数

3.内置的聚合函数（UDAF）

4.内置表生成函数（UDTF）

5.自定义函数

自定义函数包括三种UDF、UDAF、UDTF

UDF(User-Defined-Function) ：一进一出

UDAF(User- Defined Aggregation Funcation) ：聚集函数，多进一出。Count/max/min

UDTF(User-Defined Table-Generating Functions) :一进多出，如explore()

5.1 UDF 开发

1、UDF函数可以直接应用于select语句，对查询结构做格式化处理后，再输出内容。

2、编写UDF函数的时候需要注意一下几点：

a）自定义UDF需要继承org.apache.hadoop.hive.ql.UDF。

b）需要实现evaluate函数，evaluate函数支持重载。

3、步骤

(1)将jar包上传到虚拟机中：

a）把程序打包放到目标机器上去；
b）进入hive客户端，添加jar包：hive>add jar /run/jar/udf_test.jar;
c）创建临时函数：hive>CREATE TEMPORARY FUNCTION add_example AS 'hive.udf.Add';
d）查询HQL语句：
    SELECT add_example(8, 9) FROM scores;
    SELECT add_example(scores.math, scores.art) FROM scores;
    SELECT add_example(6, 7, 8, 6.8) FROM scores;
e）销毁临时函数：hive> DROP TEMPORARY FUNCTION add_example;
注意：此种方式创建的函数属于临时函数，当关闭了当前会话之后，函数会无法使用，因为jar的引用没有了，无法找到对应的java文件进行处理，因此不推荐使用。

(2)将jar包上传到hdfs集群中：

 a）把程序打包上传到hdfs的某个目录下
b）创建函数：hive>CREATE FUNCTION add_example AS 'hive.udf.Add' using jar "hdfs://mycluster/jar/udf_test.jar";
d）查询HQL语句：
    SELECT add_example(8, 9) FROM scores;
    SELECT add_example(scores.math, scores.art) FROM scores;
    SELECT add_example(6, 7, 8, 6.8) FROM scores;
e）销毁临时函数：hive> DROP  FUNCTION add_example;

Hive参数操作和运行方式

1、Hive参数操作

1、hive参数介绍

hive当中的参数、变量都是以命名空间开头的，详情如下表所示：

hive的变量可以通过${}方式进行引用，其中system、env下的变量必须以前缀开头

2、hive参数的设置方式

1、在${HIVE_HOME}/conf/hive-site.xml文件中添加参数设置
        **注意：永久生效，所有的hive会话都会加载对应的配置**
2、在启动hive cli时，通过--hiveconf key=value的方式进行设置
          例如：hive --hiveconf hive.cli.print.header=true
        **注意：只在当前会话有效，退出会话之后参数失效**
3、在进入到cli之后，通过set命令设置
        例如：set hive.cli.print.header=true;

--在hive cli控制台可以通过set对hive中的参数进行查询设置
--set设置
    set hive.cli.print.header=true;
--set查看
    set hive.cli.print.header
--set查看全部属性
    set
当前会话有效

    4、hive参数初始化设置
        在当前用户的家目录下创建**.hiverc**文件，在当前文件中设置hive参数的命令，每次进入hive cli的时候，都会加载.hiverc的文件，执行文件中的命令。
        **注意：在当前用户的家目录下还会存在.hivehistory文件，此文件中保存了hive cli中执行的所有命令**

2、hive运行方式

1、hive运行方式分类

    （1）命令行方式或者控制台模式
    （2）脚本运行方式（实际生产环境中用最多）
    （3）JDBC方式：hiveserver2
    （ 4）web GUI接口（hwi、hue等）

2、hive命令行模式详解

    （1）在命令行中可以直接输入SQL语句，例如：select * from table_name
    （2）在命令行中可以与HDFS交互，例如：dfs ls /
    （3）在命令行中可以与linux交互，例如：! pwd或者! ls /
                **注意：与linux交互的时候必须要加!**

3、hive脚本运行方式

--hive直接执行sql命令，可以写一个sql语句，也可以使用;分割写多个sql语句
    hive -e ""
--hive执行sql命令，将sql语句执行的结果重定向到某一个文件中
    hive -e "">aaa
--hive静默输出模式，输出的结果中不包含ok，time token等关键字
    hive -S -e "">aaa
--hive可以直接读取文件中的sql命令，进行执行
    hive -f file
--hive可以从文件中读取命令，并且执行初始化操作
    hive -i /home/my/hive-init.sql   //不会退出hive命令行
--在hive的命令行中也可以执行外部文件中的命令
    hive> source file (在hive cli中运行)

4、hive JDBC访问方式，之前讲过，不再赘述

5、Hive GUI方式

    ![hive hwi.png](https://cdn.nlark.com/yuque/0/2020/png/2404606/1602214279529-621d854c-55e0-4113-907e-4a6e297b7b59.png#align=left&display=inline&height=198&margin=%5Bobject%20Object%5D&name=hive%20hwi.png&originHeight=198&originWidth=1039&size=20402&status=done&style=none&width=1039)

Hive动态分区和分桶

1、Hive动态分区

1、hive的动态分区介绍

    hive的静态分区需要用户在插入数据的时候必须手动指定hive的分区字段值，但是这样的话会导致用户的操作复杂度提高，而且在使用的时候会导致数据只能插入到某一个指定分区，无法让数据散列分布，因此更好的方式是当数据在进行插入的时候，根据数据的某一个字段或某几个字段值动态的将数据插入到不同的目录中，此时，引入动态分区。

2、hive的动态分区配置

--hive设置hive动态分区开启
    set hive.exec.dynamic.partition=true;
    默认：true
--hive的动态分区模式
    set hive.exec.dynamic.partition.mode=nostrict;
    默认：strict（至少有一个分区列是静态分区）
--每一个执行mr节点上，允许创建的动态分区的最大数量(100)
    set hive.exec.max.dynamic.partitions.pernode;
--所有执行mr节点上，允许创建的所有动态分区的最大数量(1000)    
    set hive.exec.max.dynamic.partitions;
--所有的mr job允许创建的文件的最大数量(100000)    
    set hive.exec.max.created.files;

3、hive动态分区语法

--Hive extension (dynamic partition inserts):
    INSERT OVERWRITE TABLE tablename PARTITION (partcol1[=val1], partcol2[=val2] ...)         select_statement FROM from_statement;
    INSERT INTO TABLE tablename PARTITION (partcol1[=val1], partcol2[=val2] ...)             select_statement FROM from_statement;
eg
insert into table ps1 partition(age,gender)
select id,name,likes,address,age,gender from psn2   //分区字段要写在最后，且顺序和partition()申明的一样

2、Hive分桶

1、Hive分桶的介绍

    Bucketed tables are fantastic in that they allow much more efficient sampling than do non-bucketed tables, and they may later allow for time saving operations such as mapside joins. However, the bucketing specified at table creation is not enforced when the table is written to, and so it is possible for the table's metadata to advertise properties which are not upheld by the table's actual layout. This should obviously be avoided. Here's how to do it right.

    注意：
        1、Hive分桶表是对列值取hash值得方式，将不同数据放到不同文件中存储
        2、对于hive中每一个表、分区都可以进一步进行分桶
        3、由列的hash值除以桶的个数来决定每条数据划分在哪个桶中

2、创建分桶表

CREATE TABLE psn31( id INT, name STRING, age INT)
ROW FORMAT DELIMITED FIELDS TERMINATED BY ',';
测试数据：
1,tom,11
2,cat,22
3,dog,33
4,hive,44
5,hbase,55
6,mr,66
7,alice,77
8,scala,88
 创建分桶表
CREATE TABLE psnbucket( id INT, name STRING, age INT)
CLUSTERED BY (age) INTO 4 BUCKETS
ROW FORMAT DELIMITED FIELDS TERMINATED BY ',';
– 加载数据：
insert into table psnbucket select id, name, age from psn31;
– 抽样
select id, name, age from psnbucket tablesample(bucket 2 out of 4 on age);

3、Hive分桶的配置

--设置hive支持分桶 2.x之后不用设
    set hive.enforce.bucketing=true;

4、Hive分桶的抽样查询

--案例
    select * from bucket_table tablesample(bucket 1 out of 4 on columns)
--TABLESAMPLE语法：
    TABLESAMPLE(BUCKET x OUT OF y)
        x：表示从哪个bucket开始抽取数据 从1开始
        y：必须为该表总bucket数的倍数或因子
取的数据量为：桶的个数/y
如果桶的个数/y>1, 取的桶为x ,x+y...的桶    
eg;
假设有4个桶
1 out of 2
取4/2=2个桶的数据,第1和第1+2=3个桶的数据
当y为桶的倍数时，取第x个桶的一部分数据

Hive的视图和索引

1、Hive Lateral View

1、基本介绍

Lateral View用于和UDTF函数（explode、split）结合来使用。<br />    首先通过UDTF函数拆分成多行，再将多行结果组合成一个支持别名的虚拟表。主要解决在select使用UDTF做查询过程中，查询只能包含单个UDTF，不能包含其他字段、以及多个UDTF的问题。<br />    语法：<br />        LATERAL VIEW udtf(expression) tableAlias AS columnAlias (',' columnAlias)

2、案例

select count(distinct(myCol1)), count(distinct(myCol2)) from psn2 
LATERAL VIEW explode(likes) myTable1 AS myCol1 
LATERAL VIEW explode(address) myTable2 AS myCol2, myCol3;

2、Hive视图

1、Hive视图基本介绍

Hive 中的视图和RDBMS中视图的概念一致，都是一组数据的逻辑表示，本质上就是一条SELECT语句的结果集。视图是纯粹的逻辑对象，没有关联的存储(Hive 3.0.0引入的物化视图除外)，当查询引用视图时，Hive可以将视图的定义与查询结合起来，例如将查询中的过滤器推送到视图中。

2、Hive视图特点

1、不支持物化视图<br />    2、只能查询，不能做加载数据操作<br />    3、视图的创建，只是保存一份元数据，查询视图时才执行对应的子查询<br />    4、view定义中若包含了ORDER BY/LIMIT语句，当查询视图时也进行ORDER BY/LIMIT语句操作，view当中              定义的优先级更高<br />    5、view支持迭代视图

3、Hive视图语法

--创建视图：
    CREATE VIEW [IF NOT EXISTS] [db_name.]view_name 
      [(column_name [COMMENT column_comment], ...) ]
      [COMMENT view_comment]
      [TBLPROPERTIES (property_name = property_value, ...)]
      AS SELECT ... ;
--查询视图：
    select colums from view;
--删除视图：
    DROP VIEW [IF EXISTS] [db_name.]view_name;

3、Hive索引

1、hive索引

为了提高数据的检索效率，可以使用hive的索引

2、hive基本操作

--创建索引：
    create index t1_index on table psn2(name) 
    as 'org.apache.hadoop.hive.ql.index.compact.CompactIndexHandler' with deferred             rebuild in table t1_index_table;
--as：指定索引器；
--in table：指定索引表，若不指定默认生成在default__psn2_t1_index__表中
    create index t1_index on table psn2(name) 
    as 'org.apache.hadoop.hive.ql.index.compact.CompactIndexHandler' with deferred             rebuild;
--查询索引
    show index on psn2;
--重建索引（建立索引之后必须重建索引才能生效）
    ALTER INDEX t1_index ON psn2 REBUILD;
--删除索引
    DROP INDEX IF EXISTS t1_index ON psn2;

Hive权限管理

1、hive授权模型介绍

（1）Storage Based Authorization in the Metastore Server
基于存储的授权 - 可以对Metastore中的元数据进行保护，但是没有提供更加细粒度的访问控制（例如：列级别、行级别）。
（2）SQL Standards Based Authorization in HiveServer2
基于SQL标准的Hive授权 - 完全兼容SQL的授权模型，推荐使用该模式。
（3）Default Hive Authorization (Legacy Mode)
hive默认授权 - 设计目的仅仅只是为了防止用户产生误操作，而不是防止恶意用户访问未经授权的数据。

2、基于SQL标准的hiveserver2授权模式

（1）完全兼容SQL的授权模型<br />    （2）除支持对于用户的授权认证，还支持角色role的授权认证<br />            1、role可理解为是一组权限的集合，通过role为用户授权<br />            2、一个用户可以具有一个或多个角色，默认包含另种角色：public、admin

3、基于SQL标准的hiveserver2授权模式的限制

    1、启用当前认证方式之后，dfs, add, delete, compile, and reset等命令被禁用。<br />        2、通过set命令设置hive configuration的方式被限制某些用户使用。<br />            （可通过修改配置文件hive-site.xml中hive.security.authorization.sqlstd.confwhitelist进行配置）<br />        3、添加、删除函数以及宏的操作，仅为具有admin的用户开放。<br />        4、用户自定义函数（开放支持永久的自定义函数），可通过具有admin角色的用户创建，其他用户都可以使用。<br />        5、Transform功能被禁用。

4、详细配置

hive-site.xml
<property>
  <name>hive.security.authorization.enabled</name>
  <value>true</value>
</property>
<property>
  <name>hive.server2.enable.doAs</name>
  <value>false</value>
</property>
<!-- root用户是管理员，多个,分隔 -->
<property>
  <name>hive.users.in.admin.role</name>
  <value>root</value>
</property>
<property>
  <name>hive.security.authorization.manager</name>  
  <value>org.apache.hadoop.hive.ql.security.authorization.plugin.sqlstd.SQLStdHiveAuthorizerFactory</value>
</property>
<property>
  <name>hive.security.authenticator.manager</name>
  <value>org.apache.hadoop.hive.ql.security.SessionStateUserAuthenticator</value>
</property>
重启hiveserver2