Hive 基本命令

喜欢ヅ旅行 2022-02-22 06:39 304阅读 0赞

### 前言 ###

总结的`Hive`相关命令. 由于本人没有在生产环境使用`Hive`. 所以,对于`Hive`的理解可能有不当之处. 又因网上的排版略差. 于是, 重新排版, 转载一篇, 记录于此.

--------------------

### DML ###

##### 建表 #####

CREATE [EXTERNAL] TABLE [IF NOT EXISTS] table_name
       [(col_name data_type[COMMENT col_comment], ...)]
       [COMMENT table_comment]
       [PARTITIONED BY (col_namedata_type [COMMENT col_comment], ...)]
       [CLUSTERED BY (col_name,col_name, ...)
       [SORTED BY (col_name[ASC|DESC], ...)] INTO num_buckets BUCKETS]
       [ROW FORMAT row_format]
       [STORED AS file_format]
       [LOCATION hdfs_path]

*  `CREATE TABLE`创建一个指定名字的表。如果相同名字的表已经存在，则抛出异常；用户可以用 IF NOT EXISTS 选项来忽略这个异常。
 *  `EXTERNAL`关键字可以让用户创建一个外部表，在建表的同时指定一个指向实际数据的路径（LOCATION），Hive 创建内部表时，会将数据移动到数据仓库指向的路径；若创建外部表，仅记录数据所在的路径，不对数据的位置做任何改变。在删除表的时候，内部表的元数据和数据会被一起删除，而外部表只删除元数据，不删除数据。

`LOCATOION`：在建外部表时指定的数据存储目录。

create external table fz_external_table(id int,name string,age int,tel string)
    ROW FORMAT DELIMITED FIELDS TERMINATED BY ','
    STORED AS TEXTFILE
    LOCATION '/user/hive/external/fz_external_table';

*  `LIKE` 允许用户复制现有的表结构，但是不复制数据: `CREATE TABLE t4 like t2;`
 *  `ROW FORMAT`: 创建表时指定的数据切分格式

DELIMITED [FIELDS TERMINATED 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, ...)]

用户在建表的时候可以自定义 SerDe 或者使用自带的 SerDe。如果没有指定 ROW FORMAT 或者 ROW FORMAT DELIMITED，将会使用自带的 SerDe。在建表的时候，用户还需要为表指定列，用户在指定表的列的同时也会指定自定义的SerDe，Hive通过 SerDe 确定表的具体的列的数据。

`SerDe`是`Serialize/Deserilize`的简称，目的是用于序列化和反序列化. 例如：

CREATE TABLE psn (
        id int,
        name string,
        hobbies ARRAY <string>,
        address MAP <string, string>
    )
    ROW FORMAT DELIMITED
    FIELDS TERMINATED BY ','
    COLLECTION ITEMS TERMINATED BY '-'
    MAP KEYS TERMINATED BY ':';
    
    参考：https://www.cnblogs.com/zkio/p/7283770.html

*  `STORED AS: SEQUENCEFILE|TEXTFILE|RCFILE`

如果文件数据是纯文本，可以使用 `STORED AS TEXTFILE`：默认格式，数据不做压缩，磁盘开销大，数据解析开销大。

如果数据需要压缩，使用`STORED AS SEQUENCEFILE`：支持三种压缩选择：NONE，RECORD，BLOCK。Record压缩率低，一般建议使用BLOCK压缩。

`RCFILE`是一种行列存储相结合的存储方式。首先，其将数据按行分块，保证同一个record在一个块上，避免读一个记录需要读取多个block。其次，块数据列式存储，有利于数据压缩和快速的列存取。

CREATE TABLE if not exists testfile_table( site string, url  string, pv   bigint, label string)
    ROW FORMAT DELIMITED FIELDS TERMINATED BY '\t'
    STORED AS textfile;
    LOAD DATA LOCAL INPATH '/app/weibo.txt'
    OVERWRITE INTO TABLE textfile_table;

*  `CLUSTERED BY`:

对于每一个表（table）或者分区， Hive可以进一步组织成桶，也就是说桶是更为细粒度的数据范围划分。Hive也是 针对某一列进行桶的组织。Hive采用对列值哈希，然后除以桶的个数求余的方式决定该条记录存放在哪个桶当中。

`SORTED BY`：对桶中的一个或多个列另外排序。

把表（或者分区）组织成桶（Bucket）有两个理由：

*  获得更高的查询处理效率。桶为表加上了额外的结构，Hive 在处理有些查询时能利用这个结构。具体而言，连接两个在（包含连接列的）相同列上划分了桶的表，可以使用 Map 端连接 （Map-side join）高效的实现。比如JOIN操作。对于JOIN操作两个表有一个相同的列，如果对这两个表都进行了桶操作。那么将保存相同列值的桶进行JOIN操作就可以，可以大大较少JOIN的数据量。
 *  使取样（sampling）更高效。在处理大规模数据集时，在开发和修改查询的阶段，如果能在数据集的一小部分数据上试运行查询，会带来很多方便。

create table stu_buck(sno int, sname string, sex string, sage int, sdept string)
    clustered by(sno) sorted by(sno DESC) into 4 buckets
    row format delimited fields terminated by ',';

*  COMMENT：可以为表与字段增加描述
 *  PARTITIONED BY ：根据分区来查看表中的内容，每个分区以文件夹的形式单独存在表文件夹的目录下。

##### 具体实例： #####

创建内部表的三种方式：

*  第一种方式：

# 创建表
    Create table if not exists default.weblog( Ip string, Time string, Req_url string, Status string, Size string)
    Row format delimited fields terminated by ‘\t’;
    
    #数据存储：
    Load data local inpath’/opt/hive/weblog.txt’ into table default.weblog;
    
    #查看数据：
    Select * from default.weblog;

*  第二种方式：

# 创建表
    Create table default.weblog
    As select ip, time, req_url, from default.weblog;
    
    #查看表结构：
    Desc default.weblog;

*  第三种方式：
 *  创建内部表

# 创建表
    Create table if not exists default.weblog_s like default.weblog;
    # 查看表
    Select * from weblog;
    # 查看表结构
    Desc weblog;

*  创建外部表pageview.

Create external table if not exists pageview(Pageid int, Page_url string comment ‘the page url’)
    Row format delimited fields terminated by ‘,’
    Location ‘hdfs://192.168.11.191:9000/user/hive/warehouse/’;

*  创建分区表`invites`.

分区是指将数据放在多个单独的文件夹中，减少运行的时间.

create table student_p(Sno int, Sname string, Sex string, Sage int,Sdept string)
    partitioned by(part string)
    row format delimited fields terminated by ','
    stored as textfile;
    
    # 内部分区表：
    create table student(id int, name string) 
    partitioned by (cls string) 
    row format delimited fields terminated by '\t';
    
    # 分区表装载数据：
    load data local inpath '/home/airib/work/hadoop/book' into table student partition (cls='class2');
    
    # 外部分区表：可以单独的往某个分区中导入数据；
    
    create external table teacher (id int, name string)
    partitioned by (cls string)
    row format delimited fields terminated by '\t' location '/user/teacher';
    location '/user/teacher'

*  创建带桶的表：

> 如何理解分桶?  
> 对于某一个表或者分区，hive可以进一步构建成桶，是更为细粒度的划分；一开始数据都是在一起的，建造表的时候会按照id将表分在四个文件中，分别命名为1,2,3,4；数据会对应的存入到这四个文件中，数据的存取方式为将数据按照id进行hash散列，然后按照hash散列分到四个文件中。

分桶建表的基本语法为:

Create table student(Id int, Age int,Name string)
    Partitioned by (stat_Date string)
    Clustered by (id) sorted by (age) into 2 buckets
    Row format delimited fields terminated by ‘,’;

注意：

*  对于已有的数据，将数据导入到分桶的表中的时候是不主动分桶的，他只是记录了数据是分过桶的，文件没有变，因此在load数据的时候一般先分桶，再导入数据；
 *  分桶处理时一般采用insert语句，分布进行，步骤如下：

>  *  首先：将数据load进入到一个普通的表中；
> 
>     Create table t_p(id string, name string)
>     Row format delimited fields terminated by ‘,’;
> 
>  *  其次：有一个分桶的开关需要打开：
> 
>     set hive.enforce.bucketing = true;
>     set mapreduce.job.reduces = 4;
> 
>  *  其三：然后将数据按照分桶原则从表中插入到分桶的表中，经历以下语句，数据就会被完整的分到四个桶中，四个桶分为四个不同的文件：
> 
>     Insert into table t_buck
>     Select id, name from t_p distribute by (id) sort by (id);
> 
> reduce的数量需要与分桶的数量一致。

### 修改表 ###

*  增加/删除分区

ALTER TABLE table_name
    ADD [IF NOT EXISTS]
    partition_spec [ LOCATION'location1' ]
    partition_spec [ LOCATION 'location2' ] ...
    
    其中partition_spec为：
    PARTITION (partition_col = partition_col_value, partition_col =partiton_col_value, ...)
    ALTER TABLE table_name DROP partition_spec, partition_spec,...

*  增加分区：

alter table student_p add partition(part='a') partition(part='b')；

*  删除分区：

show partitions student;
    alter table student_p drop partition(stat_date='20160105');
    alter table student_p add partition(stat_date=’20140101’)
    location ‘/user/hive/warehouse/student’ partition(stat_Date=’ 20140102’)

*  重命名表:

语法结构:
    ALTER TABLE table_name RENAME TO new_table_name

具体实例:

alter table students renameto students1;
    show tables;

*  增加/更新列:

语法结构:
    
    ALTER TABLE table_name
    ADD|REPLACE COLUMNS (
    col_name data_type[COMMENT col_comment], ...
    )
    
    ALTER TABLE table_name
    CHANGE [COLUMN] col_old_name col_new_namecolumn_type
    [COMMENT col_comment]
    [FIRST|AFTER column_name]

注: ADD是代表新增一字段，字段位置在所有列后面(partition列前)，REPLACE则是表示替换表中所有字段，Change是修改列及属性。

*  增加列：

Alter table students add columns(name1 string);

*  更新列：

Alter table students replace columns(id int, age int, name string);

*  删除列：

alter table students drop columns id;

*  修改列：

alter table students change columns salary salary double;

*  删除表：

drop table if exists employee;

*  修改桶：

alter table btest3 clustered by(name, age) sorted by(age) into10 buckets;

##### 显示命令 #####

show tables
    show databases
    show partitions t_name;
    show functions
    desc extended t_name;
    desc formatted table_name;

--------------------

## DDL ##

##### Load(复制/移动操作)： #####

语法结构：
    LOAD DATA [LOCAL] INPATH 'file path' [OVERWRITE] INTO
    TABLE tablename
    [PARTITION (partcol1=val1, partcol2=val2 ...)]

说明：

*  Load 操作只是单纯的复制/移动操作，将数据文件移动到 Hive 表对应的位置。
 *  file path移动路径:
    
     *  相对路径，例如：project/data1
     *  绝对路径，例如：/user/hive/project/data1
     *  包含模式的完整 URI，列如：hdfs://namenode:9000/user/hive/project/data1
 *  LOCAL关键字：

如果没有指定 LOCAL 关键字，则根据inpath中的uri查找文件.如果指定了LOCAL，那么, load 命令会去查找本地文件系统中的file path。如果发现是相对路径，则路径会被解释为相对于当前用户的当前路径。

load 命令会将file path中的文件复制到目标文件系统中。目标文件系统由表的位置属性决定。被复制的数据文件移动到表的数据对应的位置。

如果没有指定 LOCAL关键字，如果file path指向的是一个完整的URI，hive 会直接使用这个URI。否则：如果没有指定schema或者authority，Hive 会使用在hadoop配置文件中定义的schema和authority，fs.default.name指定了 Namenode的URI。

如果路径不是绝对的，Hive相对于/user/进行解释。

Hive 会将filepath中指定的文件内容移动到table（或者partition）所指定的路径中。

*  `OVERWRITE`关键字

如果使用了OVERWRITE关键字，则目标表（或者分区）中的内容会被删除，然后再将file path指向的文件/目录中的内容添加到表/分区中。

如果目标表（分区）已经有一个文件，并且文件名和file path中的文件名冲突，那么现有的文件会被新文件所替代。

*  加载相对路径数据：

Load data local inpath ‘buckets.txt’ into table student partition(stat_Date=’20130202’);
    Dfs -ls /user/hive/warehouse/student/stat_date=20130202

*  加载绝对路径数据:

Load data local inpath ‘/root/app/datafile/buckets.txt’ into table student partition(stat_Date=’20130202’);
    Dfs -ls /user/hive/warehouse/student/stat_date=20130202;

*  加载包含模式的完整url：

Load data local inpath ‘http://192.168.22.22:9000/root/app/datafile/buckets.txt’ into table student partition(stat_Date=’20130202’);
    Dfs -ls /user/hive/warehouse/student/stat_date=20130202;

*  `OVERWRITE`关键字使用:

Load data local inpath ‘buckets.txt’ overwrite into table student partition(stat_Date=’20130202’);
    Dfs -ls /user/hive/warehouse/student/stat_date=20130202;

##### Insert（插入语句） #####

Insert(插入语句): 将查询结果插入Hive表.

语法结构：
    
    ### Base insert：
    INSERT OVERWRITE TABLE tablename1
    [PARTITION (partcol1=val1, partcol2=val2 ...)]
    SELECT select_statement1
    FROM from_statement
    
    ### Multiple inserts:
    
    FROM from_statement
    INSERT OVERWRITE TABLE tablename1
    [PARTITION (partcol1=val1, partcol2=val2 ...)]
    SELECT select_statement1
    [INSERT OVERWRITE TABLE tablename2
    [PARTITION ...]
    SELECT select_statement2] ...
    
    ### Dynamic partition inserts:
    
    INSERT OVERWRITE TABLE tablename
    PARTITION (partcol1[=val1], partcol2[=val2] ...)
    SELECT select_statement
    FROM from_statement

*  具体案例：
 *  `追加数据`: insert into是指后面追加内容，原有的内容不删除；

insert into table account1 select * from account_tmp;

*  覆盖数据：覆盖原有的内容；

insert overwrite table account1 select * from account_tmp;

*  多插入模式：

From student
    Insert overwrite table student partition(stat_date=’20140202’)
    Select id, age, name, where stat_date=’20130202’
    Insert overwrite table student partition(stat_date=’20140203’)
    Select id, age, name, where stat_date=’20130203’

*  动态分区模式:

Insert overwrite table student1 partition(stat_date)
    Select id, age, name, stat_date from student where stat_date=’20140203’

##### 导出表数据 #####

*  导出表数据：

### Base insert：
    INSERT OVERWRITE [LOCAL] DIRECTORY directory1
    SELECT ... FROM ...
    
    ### multiple inserts:
    FROM from_statement
    INSERT OVERWRITE [LOCAL] DIRECTORY directory1
    SELECT select_statement1
    [INSERT OVERWRITE [LOCAL] DIRECTORY directory2
    SELECT select_statement2]...

具体实例：

*  导出文件到本地：

Insert overwrite local directory ‘/root/app/datafile/student1’
    Select * from student1

说明：数据写入到文件系统时进行文本序列化，且每列用^A来区分，\\n为换行符。用more命令查看时不容易看出分割符，可以使用: sed -e ‘s/\\x01/|/g’ filename来查看。

*  导出数据到HDFS:

Insert overwrite directory ‘hdfs://192.168.122.11:9000/user/hive/warehouse/mystudent’
    Select * from student1;
    Dfs -ls /user/hive/warehouse/mystudent;

注意：

`insert...select`: 一般是表对表. 往表中导入数据时，查询的字段个数必须和目标的字段个数相同，不能多，也不能少,否则会报错。但是如果字段的类型不一致的话，则会使用null值填充，不会报错。

`load data`: 一般是将外部文件放到hive中. 形式往hive表中装载数据时，则不会检查。如果字段多了则会丢弃，少了则会null值填充。同样如果字段类型不一致，也是使用null值填充。

##### SELECT #####

1）语法结构：
    
    SELECT [ALL | DISTINCT]
    select_expr, select_expr, ...
    FROM table_reference
    [WHERE where_condition]
    [GROUP BY col_list [HAVING condition]]
    [CLUSTER BY col_list|[DISTRIBUTE BY col_list] [SORT BY| ORDER BY col_list]]
    [LIMIT number]

注：

*  `order by`: 会对输入做全局排序，因此只有一个reducer，会导致当输入规模较大时，需要较长的计算时间。
 *  `sort by`: 不是全局排序，其在数据进入reducer前完成排序。因此，如果用sort by进行排序，并且设置mapred.reduce.tasks>1，则sort by只保证每个reducer的输出有序，不保证全局有序。
 *  `distribute by(字段)`: 根据指定的字段将数据分到不同的reducer，且分发算法是hash散列。
 *  `cluster by（字段)`: 除了具有Distribute by的功能外，还会对该字段进行排序。  
    如果分桶和sort字段是同一个时，此时：cluster by = distribute by + sort by  
    分桶表的作用：最大的作用是用来提高join操作的效率；

（思考这个问题：select a.id, a.name, b.addr from a join b on a.id = b.id;
    
    如果a表和b表已经是分桶表，而且分桶的字段是id字段
    
    做这个join操作时，还需要全表做笛卡尔积吗？）

保存select查询结果的几种方式：

*  将查询结果保存到一张新的hive表中：

Create table t_tmp
    As
    Select * from t_p;

*  将查询结果保存到一张已经存在的hive表中：

Insert into table t_tmp
    Select * from t_p;

*  将查询结果保存到指定的文件目录中（可以是本地，也可以是hdfs）：

Insert into local directory ‘/home/Hadoop/test’
    Select * from t_p;

*  具体实例:
 *  获取年龄大的3个学生:

Select id, age, name
    from student
    where stat_date=’20140203’
    order by age desc
    limit 3;

*  查询学生信息按年龄，降序排序:  
    Order by：全局排序，生成一个reducer；  
    Sort by：分区内排序，可生成多个reducer；

Set mapred.reduce.tasks=4;
    Select * from student sort by age desc;

*  按学生名称汇总学生年龄:

Select name, sum(age) from student group by name;

*  分区划分查询：

`Distribute by`：按照指定的字段或表达式对数据进行划分，输出到对应的reduce或者文件中；

`cluster by`：区内排序，如果distribute by，sort by使用的两个字段相同时：cluster by=distribute by+sort by功能叠加；

set mapred.reduce.tasks=2;
    insert overwrite local directory 'tmp/lxw1234/'
    select id from lxw1234_com
    distribute by id;

上面会生成两个文件；

set mapred.reduce.tasks=2;
    insert overwrite local directory 'tmp/lxw1234/' 
    select id from lxw1234_com
    cluster by id;

上面会排序；

*  子查询：必须设置别名

select * from (select a+b as col form t1) t2;

*  where中的子查询：

left semi join语句用来替代exists/in子句：

在hive中下面的语句是无法使用的：

select * from A where A.a in (select foo from B);
    
    select * from A where A.a exists (select foo from B where A.x=B.x);

需要使用left semi join子句：

select * from A left semi join B on(A.key=B.key);

*  将子查询作为一个表：hive可以通过with查询来提高查询性能，因为先通过with语法将数据查询到内存，然后后面其它查询可以直接使用。

with q1 as (select * from A where x>65)
    
    from q1
    
    insert overwrite table q2
    
    select *;

*  虚拟列：

input_file_name:数据对应的HDFS文件；
    
    block_offset_inside_file:该行记录在文件中的偏移量；
    
    select id, input_file_name, block_offset_inside_file from lxm1234_com;

##### Hive Join： #####

语法结构：
    join_table:
    table_reference JOIN table_factor [join_condition]
      | table_reference {LEFT|RIGHT|FULL}  [OUTER]  JOIN table_reference join_condition
      | table_reference LEFT SEMIJOIN table_reference  join_condition

*  Hive支持等值连接(equalityjoins)\\外连接(outer joins)和左右连接(left/rightjoins)。
 *  Hive不支持非等值的连接，因为非等值连接非常难转化到 map/reduce 任务。
 *  另外，Hive支持多于2个表的连接，缓存前面的表，拿最后一个表逐行进行join。

`Join`注意几个关键点：

*  只支持等值join. 例如：

###正确
    SELECT a.* FROM a JOIN b ON (a.id = b.id)
    SELECT a.* FROM a JOIN b ON (a.id = b.id AND a.department =b.department)
    ### 错误
    SELECT a.* FROM a JOIN b ON (a.id>b.id)

*  可以 join 多于2个表. 例如：

SELECT a.val,b.val, c.val
    FROM a JOIN b
    ON (a.key =b.key1) JOIN c ON (c.key = b.key2)

*  如果join中多个表的join key是同一个，则join会被转化为单个map/reduce 任务，例如：

SELECT a.val,b.val, c.val
    FROM a JOIN b
    ON (a.key =b.key1) JOIN c ON (c.key =b.key1)
    ### 被转化为单个map/reduce任务，因为join中只使用了b.key1作为join key。
    
    SELECT a.val, b.val, c.val
    FROM a JOIN b
    ON (a.key =b.key1) JOIN c ON(c.key = b.key2)
    
    ### 而这一join 被转化为2个map/reduce任务。因为b.key1用于第一次join 条件，而b.key2用于第二次join。

*  join 时，每次 map/reduce 任务的逻辑如下: reducer会缓存join序列中除了最后一个表的所有表的记录，再通过最后一个表将结果序列化到文件系统。这一实现有助于在reduce端减少内存的使用量。实践中，应该把最大的那个表写在最后(否则会因为缓存浪费大量内存). 例如：

SELECT a.val, b.val, c.val
    FROM a JOIN b
    ON(a.key = b.key1) JOIN c ON (c.key = b.key1)

所有表都使用同一个join key（使用 1 次 map/reduce 任务计算）。Reduce 端会缓存a表和b表的记录，然后每次取得一个c表的记录就计算一次join 结果，类似的还有：

SELECT a.val,b.val, c.val
    FROM a JOIN b
    ON(a.key = b.key1) JOIN c ON (c.key = b.key2)

这里用了2次map/reduce任务。第一次缓存a表，用b表序列化；第二次缓存第一次 map/reduce 任务的结果，然后用c表序列化。

*  `LEFT`，`RIGHT`和`FULL OUTER`关键字用于处理join中空记录的情况. 例如：

SELECT a.val, b.val
    FROM a LEFT OUTER JOIN b
    ON (a.key=b.key)

对应所有a表中的记录都有一条记录输出。输出的结果应该是a.val,b.val，当 a.key=b.key时，而当b.key中找不到等值的a.key记录时也会输出: `a.val, NULL`.  
所以 a 表中的所有记录都被保留了.

SELECT A.val, B.val
    FROM A RIGHT OUTER JOIN B
    ON(A.key=B.key);
    会保留所有b表的记录。

*  Join 发生在 WHERE 子句之前：

如果你想限制join的输出，应该在WHERE子句中写过滤条件——或是在join 子句中写。这里面一个容易混淆的问题是表分区的情况：

SELECT a.val,b.val
    FROM a LEFT OUTER JOIN b
    ON (a.key=b.key)
    WHERE a.ds='2009-07-07' AND b.ds='2009-07-07'

上例会join a表到b表（OUTER JOIN），列出a.val和b.val的记录。WHERE 从句中可以使用其他列作为过滤条件。但是，如前所述，如果 b 表中找不到对应 a 表的记录，b 表的所有列都会列出 NULL，包括 ds 列。也就是说，join 会过滤 b 表中不能找到匹配a表join key的所有记录。这样的话，LEFT OUTER就使得查询结果与WHERE子句无关了。解决的办法是在OUTER JOIN时使用以下语法：

SELECT a.val, b.val
    FROM a LEFT OUTER JOIN b
    ON (a.key=b.key AND b.ds='2009-07-07' AND a.ds='2009-07-07')

这一查询的结果是预先在join阶段过滤过的，所以不会存在上述问题。这一逻辑也可以应用于RIGHT和FULL类型的join中。

*  Join 是不能交换位置的：

无论是LEFT还是RIGHT join，都是左连接的。

SELECT a.val1,a.val2, b.val, c.val
    FROM a JOIN b ON(a.key = b.key)
    LEFT OUTER JOIN c ON (a.key = c.key)

先join a表到b表，丢弃掉所有join key中不匹配的记录，然后用这一中间结果和c表做join。这一表述有一个不太明显的问题，就是当一个key在a表和c表都存在，但是b表中不存在的时候：整个记录在第一次join，即a JOIN b的时候都被丢掉了（包括a.val1，a.val2和a.key），然后我们再和c 表 join的时候，如果c.key与a.key或b.key相等，就会得到这样的结果：NULL, NULL, NULL, c.val

*  内连接inner join,只返回满足条件的结果：

SELECT t.dept, e.name
    FROM employees e INNER JOIN dept t
    ON e.deptno=t.deptno;

*  查询带桶的内容：

SELECT *
    FROM bucketed_user
    TABLESAMPLE(bucket 1 out of 2 on id)
    WHERE day='20180703';

语法：
    `tablesample（bucket x out of y）：桶抽样

y必须是table总bucket数的因子或者倍数。hive根据y的大小决定抽样的比例。

例如：table共有64份，当y=32时，抽取（64/32）个bucket，即两个，当y=128时，抽取（64/128）=1/2个桶的数据；

x表示从哪个桶开始抽数据。

例如：table总bucket数为32，tablesample(bucket 3 out of 16),表示总共抽取（32/16）=2个bucket的数据，分别为第3个bucket和第3+16=19个bucket的数据；

##### update： #####

*  hive中的update语句会有一定的限制：
    
     *  必须带有分桶属性（buckets）；
     *  需要指定orc file format和acid output format格式；
     *  建表时必须指定参数（‘transactional’=true）；
     *  必须首先修改hive-site.xml中的内容；
 *  其次：

Create table student(id int,name string)clustered by(name) into 2 buckets 
    stored as orc tblproperties('transactional'='true');

*  其三：

update student set id='444' 
    where name='tom';

##### delete： #####

*  删除表：

Drop table if exists students;

*  删除表中所有内容：

Truncate table employees;

*  删除表中部分数据：

Insert overwrite table table1 select * from table1 where XXXX;
    XXXX是表中需要保留的数据；

具体实例：

*  获取已经分配班级的学生姓名：