Hive_HQL_Hive优化_复杂SQL_观看不同视频个数的前5名

已于 2023-07-20 18:12:05 修改
阅读量1k 收藏 1
点赞数
分类专栏： SQL 文章标签： hive sql 音视频
于 2020-06-04 09:44:21 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010003835/article/details/106536970
版权

今天，遇到了一个问题，求 : 某一天HIVE分区表的数据，观看视频个数不同的前5名user_id。

问题描述 ：

用户浏览日志（date, user_id, video_id）, 统计 2020.03.29 观看不同视频个数的前5名 user_id。（大数据集）
 

先创建表，并构建数据

CREATE TABLE IF NOT EXSITS user_video_log(
	user_id BIGINT,
	video_id BIGINT
)PARTITIONED BY(
	pt STRING
);

INSERT OVERWRITE TABLE user_video_log PARTITION( pt = '20200603')
VALUES
(1,1)
,(1,1)
,(1,2)
,(1,3)
,(1,4)
,(1,5)
,(1,6)
,(2,1)
,(2,2)
,(2,2)
,(2,3)
,(2,4)
,(2,5)
,(3,1)
,(4,1)
,(5,1)
,(6,1)
,(7,1)
,(7,1)
,(7,1)
,(7,2)
,(7,2)
,(7,3)
,(7,4)
,(7,4)
;

注意

这里有两个坑，

Hive_HIVE优化指南_场景一_去重场景问题_高达一号的博客-CSDN博客

1.COUNT(DISTINCT)

优化原理

我们先说下为什么大数据集下  先 GROUP BY 再COUNT 的效率 要优于 直接 COUNT(DISTINCT ...) .

因为 COUNT(DISTINCT ...)  , 会把相关的列组成一个key 传入到 Reducer 中。即 count(DISTINCT KEY._col0:0._col0, KEY._col0:0._col1, KEY._col0:0._col2) |   这样需要在 一个 Reducer 中 ，完成全排序并去重。

先GROUP BY 再去 COUNT ，则GROUP BY 可以 将不同的KEY , 分发到多个 Reducer 中，在 GROUP BY流程中完成了去重。此时，去重时并不会把数据放入到 一个 Reducer 中，利用了分布式的优势。这个去重效率更高。在下一步 COUNT 阶段，再将上一步奏 GROUP BY 去重后的 KEY , 进行统计计算。

所以大数据量下 先GROUP BY ，再去 COUNT    效率比  COUNT(DISTINCT)  更高。
 

2.使用全局排序ORDER BY

会把数据打到一个reducer task 中!

错误写法

SELECT user_id, differ_video
FROM
(
    SELECT user_id, COUNT(DISTINCT video_id) AS differ_video
    FROM
        user_video_log
    WHERE pt = '20200603'
) tmp
ORDER BY differ_video DESC 
LIMIT 5;

执行计划

+----------------------------------------------------+
|                      Explain                       |
+----------------------------------------------------+
| STAGE DEPENDENCIES:                                |
|   Stage-1 is a root stage                          |
|   Stage-2 depends on stages: Stage-1               |
|   Stage-0 depends on stages: Stage-2               |
|                                                    |
| STAGE PLANS:                                       |
|   Stage: Stage-1                                   |
|     Map Reduce                                     |
|       Map Operator Tree:                           |
|           TableScan                                |
|             alias: user_video_log                  |
|             filterExpr: (pt = '20200603') (type: boolean) |
|             Statistics: Num rows: 25 Data size: 400 Basic stats: COMPLETE Column stats: NONE |
|             Select Operator                        |
|               expressions: user_id (type: bigint), video_id (type: bigint) |
|               outputColumnNames: user_id, video_id |
|               Statistics: Num rows: 25 Data size: 400 Basic stats: COMPLETE Column stats: NONE |
|               Group By Operator                    |
|                 aggregations: count(DISTINCT video_id) |
|                 keys: user_id (type: bigint), video_id (type: bigint) |
|                 mode: hash                         |
|                 outputColumnNames: _col0, _col1, _col2 |
|                 Statistics: Num rows: 25 Data size: 400 Basic stats: COMPLETE Column stats: NONE |
|                 Reduce Output Operator             |
|                   key expressions: _col0 (type: bigint), _col1 (type: bigint) |
|                   sort order: ++                   |
|                   Map-reduce partition columns: _col0 (type: bigint) |
|                   Statistics: Num rows: 25 Data size: 400 Basic stats: COMPLETE Column stats: NONE |
|       Execution mode: vectorized                   |
|       Reduce Operator Tree:                        |
|         Group By Operator                          |
|           aggregations: count(DISTINCT KEY._col1:0._col0) |
|           keys: KEY._col0 (type: bigint)           |
|           mode: mergepartial                       |
|           outputColumnNames: _col0, _col1          |
|           Statistics: Num rows: 12 Data size: 192 Basic stats: COMPLETE Column stats: NONE |
|           File Output Operator                     |
|             compressed: false                      |
|             table:                                 |
|                 input format: org.apache.hadoop.mapred.SequenceFileInputFormat |
|                 output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat |
|                 serde: org.apache.hadoop.hive.serde2.lazybinary.LazyBinarySerDe |
|                                                    |
|   Stage: Stage-2                                   |
|     Map Reduce                                     |
|       Map Operator Tree:                           |
|           TableScan                                |
|             Reduce Output Operator                 |
|               key expressions: _col1 (type: bigint) |
|               sort order: -                        |
|               Statistics: Num rows: 12 Data size: 192 Basic stats: COMPLETE Column stats: NONE |
|               TopN Hash Memory Usage: 0.1          |
|               value expressions: _col0 (type: bigint) |
|       Reduce Operator Tree:                        |
|         Select Operator                            |
|           expressions: VALUE._col0 (type: bigint), KEY.reducesinkkey0 (type: bigint) |
|           outputColumnNames: _col0, _col1          |
|           Statistics: Num rows: 12 Data size: 192 Basic stats: COMPLETE Column stats: NONE |
|           Limit                                    |
|             Number of rows: 5                      |
|             Statistics: Num rows: 5 Data size: 80 Basic stats: COMPLETE Column stats: NONE |
|             File Output Operator                   |
|               compressed: false                    |
|               Statistics: Num rows: 5 Data size: 80 Basic stats: COMPLETE Column stats: NONE |
|               table:                               |
|                   input format: org.apache.hadoop.mapred.SequenceFileInputFormat |
|                   output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat |
|                   serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe |
|                                                    |
|   Stage: Stage-0                                   |
|     Fetch Operator                                 |
|       limit: 5                                     |
|       Processor Tree:                              |
|         ListSink                                   |
|                                                    |
+----------------------------------------------------+

输出

INFO  : MapReduce Jobs Launched: 
INFO  : Stage-Stage-1: Map: 1  Reduce: 5   Cumulative CPU: 16.48 sec   HDFS Read: 30865 HDFS Write: 613 SUCCESS
INFO  : Stage-Stage-2: Map: 1  Reduce: 1   Cumulative CPU: 4.44 sec   HDFS Read: 7131 HDFS Write: 167 SUCCESS
INFO  : Total MapReduce CPU Time Spent: 20 seconds 920 msec
INFO  : Completed executing command(queryId=hive_20200603213400_312b6a86-0b0f-446d-8dfe-f3c7672d9845); Time taken: 78.274 seconds
INFO  : OK
+----------+---------------+
| user_id  | differ_video  |
+----------+---------------+
| 1        | 6             |
| 2        | 5             |
| 7        | 4             |
| 6        | 1             |
| 4        | 1             |
+----------+---------------+

注意 ： 可以看到虽然设置了5个reduce task , 但是全排序还是用了一个task

数据查询

use data_warehouse_test;

set mapred.reduce.tasks=5;

SELECT user_id, video_id
FROM
    user_video_log
WHERE pt = '20200603' 
SORT BY user_id
;

EXPLAIN
SELECT user_id, differ_video
FROM 
(
	SELECT user_id, COUNT(1) AS differ_video
	FROM
	(
		SELECT user_id, video_id
		FROM
		(
			SELECT * 
			FROM user_video_log
			WHERE pt = '20200603'
		) tmp
		GROUP BY user_id, video_id
	) tmp2
	GROUP BY user_id
) tmp3
SORT BY differ_video DESC
LIMIT 5
;

SELECT user_id, differ_video
FROM 
(
	SELECT user_id, COUNT(1) AS differ_video
	FROM
	(
		SELECT user_id, video_id
		FROM
		(
			SELECT * 
			FROM user_video_log
			WHERE pt = '20200603'
		) tmp
		GROUP BY user_id, video_id
	) tmp2
	GROUP BY user_id
) tmp3
SORT BY differ_video DESC
LIMIT 5
;

分为3个部分

part1 先看下SORT BY 是不是分段有序的

part2 看下作业：取观看不同视频用户的前5名  的执行计划

part3 取观看不同视频用户的前5名

part1输出

+----------+-----------+
| user_id  | video_id  |
+----------+-----------+
| 2        | 5         |
| 3        | 1         |
| 1        | 6         |
| 2        | 4         |
| 7        | 1         |
| 1        | 1         |
| 1        | 4         |
| 4        | 1         |
| 7        | 1         |
| 1        | 1         |
| 1        | 3         |
| 2        | 2         |
| 2        | 2         |
| 5        | 1         |
| 7        | 1         |
| 7        | 2         |
| 1        | 5         |
| 1        | 2         |
| 2        | 3         |
| 2        | 1         |
| 6        | 1         |
| 7        | 3         |
| 7        | 2         |
| 7        | 4         |
| 7        | 4         |
+----------+-----------+

可以看到是分段有序的，5段，每一段都是有序的

part2 输出

可以看到作业拆分为了4个部分

+----------------------------------------------------+
|                      Explain                       |
+----------------------------------------------------+
| STAGE DEPENDENCIES:                                |
|   Stage-1 is a root stage                          |
|   Stage-2 depends on stages: Stage-1               |
|   Stage-3 depends on stages: Stage-2               |
|   Stage-0 depends on stages: Stage-3               |
|                                                    |
| STAGE PLANS:                                       |
|   Stage: Stage-1                                   |
|     Map Reduce                                     |
|       Map Operator Tree:                           |
|           TableScan                                |
|             alias: user_video_log                  |
|             filterExpr: (pt = '20200603') (type: boolean) |
|             Statistics: Num rows: 25 Data size: 400 Basic stats: COMPLETE Column stats: NONE |
|             Select Operator                        |
|               expressions: user_id (type: bigint), video_id (type: bigint) |
|               outputColumnNames: _col0, _col1      |
|               Statistics: Num rows: 25 Data size: 400 Basic stats: COMPLETE Column stats: NONE |
|               Group By Operator                    |
|                 keys: _col0 (type: bigint), _col1 (type: bigint) |
|                 mode: hash                         |
|                 outputColumnNames: _col0, _col1    |
|                 Statistics: Num rows: 25 Data size: 400 Basic stats: COMPLETE Column stats: NONE |
|                 Reduce Output Operator             |
|                   key expressions: _col0 (type: bigint), _col1 (type: bigint) |
|                   sort order: ++                   |
|                   Map-reduce partition columns: _col0 (type: bigint) |
|                   Statistics: Num rows: 25 Data size: 400 Basic stats: COMPLETE Column stats: NONE |
|       Execution mode: vectorized                   |
|       Reduce Operator Tree:                        |
|         Group By Operator                          |
|           keys: KEY._col0 (type: bigint), KEY._col1 (type: bigint) |
|           mode: mergepartial                       |
|           outputColumnNames: _col0, _col1          |
|           Statistics: Num rows: 12 Data size: 192 Basic stats: COMPLETE Column stats: NONE |
|           Select Operator                          |
|             expressions: _col0 (type: bigint)      |
|             outputColumnNames: _col0               |
|             Statistics: Num rows: 12 Data size: 192 Basic stats: COMPLETE Column stats: NONE |
|             Group By Operator                      |
|               aggregations: count(1)               |
|               keys: _col0 (type: bigint)           |
|               mode: complete                       |
|               outputColumnNames: _col0, _col1      |
|               Statistics: Num rows: 6 Data size: 96 Basic stats: COMPLETE Column stats: NONE |
|               File Output Operator                 |
|                 compressed: false                  |
|                 table:                             |
|                     input format: org.apache.hadoop.mapred.SequenceFileInputFormat |
|                     output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat |
|                     serde: org.apache.hadoop.hive.serde2.lazybinary.LazyBinarySerDe |
|                                                    |
|   Stage: Stage-2                                   |
|     Map Reduce                                     |
|       Map Operator Tree:                           |
|           TableScan                                |
|             Reduce Output Operator                 |
|               key expressions: _col1 (type: bigint) |
|               sort order: -                        |
|               Statistics: Num rows: 6 Data size: 96 Basic stats: COMPLETE Column stats: NONE |
|               TopN Hash Memory Usage: 0.1          |
|               value expressions: _col0 (type: bigint) |
|       Reduce Operator Tree:                        |
|         Select Operator                            |
|           expressions: VALUE._col0 (type: bigint), KEY.reducesinkkey0 (type: bigint) |
|           outputColumnNames: _col0, _col1          |
|           Statistics: Num rows: 6 Data size: 96 Basic stats: COMPLETE Column stats: NONE |
|           Limit                                    |
|             Number of rows: 5                      |
|             Statistics: Num rows: 5 Data size: 80 Basic stats: COMPLETE Column stats: NONE |
|             File Output Operator                   |
|               compressed: false                    |
|               table:                               |
|                   input format: org.apache.hadoop.mapred.SequenceFileInputFormat |
|                   output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat |
|                   serde: org.apache.hadoop.hive.serde2.lazybinary.LazyBinarySerDe |
|                                                    |
|   Stage: Stage-3                                   |
|     Map Reduce                                     |
|       Map Operator Tree:                           |
|           TableScan                                |
|             Reduce Output Operator                 |
|               key expressions: _col1 (type: bigint) |
|               sort order: -                        |
|               Statistics: Num rows: 5 Data size: 80 Basic stats: COMPLETE Column stats: NONE |
|               TopN Hash Memory Usage: 0.1          |
|               value expressions: _col0 (type: bigint) |
|       Reduce Operator Tree:                        |
|         Select Operator                            |
|           expressions: VALUE._col0 (type: bigint), KEY.reducesinkkey0 (type: bigint) |
|           outputColumnNames: _col0, _col1          |
|           Statistics: Num rows: 5 Data size: 80 Basic stats: COMPLETE Column stats: NONE |
|           Limit                                    |
|             Number of rows: 5                      |
|             Statistics: Num rows: 5 Data size: 80 Basic stats: COMPLETE Column stats: NONE |
|             File Output Operator                   |
|               compressed: false                    |
|               Statistics: Num rows: 5 Data size: 80 Basic stats: COMPLETE Column stats: NONE |
|               table:                               |
|                   input format: org.apache.hadoop.mapred.SequenceFileInputFormat |
+----------------------------------------------------+
|                      Explain                       |
+----------------------------------------------------+
|                   output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat |
|                   serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe |
|                                                    |
|   Stage: Stage-0                                   |
|     Fetch Operator                                 |
|       limit: 5                                     |
|       Processor Tree:                              |
|         ListSink                                   |
|                                                    |
+----------------------------------------------------+

part3 结果

两次执行结果

INFO  : Stage-Stage-1: Map: 1  Reduce: 5   Cumulative CPU: 18.41 sec   HDFS Read: 31097 HDFS Write: 613 SUCCESS
INFO  : Stage-Stage-2: Map: 1  Reduce: 5   Cumulative CPU: 11.06 sec   HDFS Read: 14785 HDFS Write: 575 SUCCESS
INFO  : Stage-Stage-3: Map: 1  Reduce: 1   Cumulative CPU: 3.68 sec   HDFS Read: 6923 HDFS Write: 167 SUCCESS
INFO  : Total MapReduce CPU Time Spent: 33 seconds 150 msec
INFO  : Completed executing command(queryId=hive_20200603211837_67bfdd47-82e1-4dd6-81a8-456e80663079); Time taken: 127.029 seconds
INFO  : OK
+----------+---------------+
| user_id  | differ_video  |
+----------+---------------+
| 1        | 6             |
| 2        | 5             |
| 7        | 4             |
| 6        | 1             |
| 4        | 1             |
+----------+---------------+
5 rows selected (127.212 seconds)

INFO  : MapReduce Jobs Launched: 
INFO  : Stage-Stage-1: Map: 1  Reduce: 5   Cumulative CPU: 16.01 sec   HDFS Read: 31097 HDFS Write: 613 SUCCESS
INFO  : Stage-Stage-2: Map: 1  Reduce: 5   Cumulative CPU: 10.6 sec   HDFS Read: 14785 HDFS Write: 575 SUCCESS
INFO  : Stage-Stage-3: Map: 1  Reduce: 1   Cumulative CPU: 4.45 sec   HDFS Read: 6923 HDFS Write: 167 SUCCESS
INFO  : Total MapReduce CPU Time Spent: 31 seconds 60 msec
INFO  : Completed executing command(queryId=hive_20200603213610_f0088785-9727-48ee-81bd-7bbcf531b486); Time taken: 122.529 seconds
INFO  : OK
+----------+---------------+
| user_id  | differ_video  |
+----------+---------------+
| 1        | 6             |
| 2        | 5             |
| 7        | 4             |
| 6        | 1             |
| 4        | 1             |
+----------+---------------+

高达一号
关注
专栏目录
大数据之Hive详解
08-06
Hive是基于Hadoop的一个数据仓库工具，可以将结构化的数据文件映射为一张表，并提供类SQL查询功能。是hadoop的一个数据仓库工具，可以将结构化的数据文件映射为一张表，并提供类SQL查询功能。本质是将HQL转化成MapReduce程序.本课程从基本概念,hive和mysql软件的安装入手,讲解hive的数据类型,DDL和DML操作,以及常用的查询和函数的使用,让你快速入门hive,即刻成为大数据程序员.
Hive 优化实践 -- 执行计划
Nice的博客
05-08 941
目录数据准备执行计划问题分析SQL优化最后小结 数据准备 -- 创建数据库 create database tuning; use tuning; -- 创建表 create table if not exists tuning.student_txt( s_no string comment '学号', s_name string comment '姓名', s_birth string comment '出生日期', s_age int comment '年龄', s_sex string comme
SQL_SQL_常见面试问题
迎难而上
07-20 199
问题类型 ：窗口函数使用。
hiveSQL:统计视频观看数Top50所关联视频的所属类别Rank
weixin_45937224的博客
03-26 2433
hive企业实战例题
mysql DISTINCT top 5 去重
liyanlei的专栏
03-26 650
如果表字段是：id, author_id, version, rank, …… 假设表数据如下 30，1，100，200…… 29，2，100，190…… 28，3，100，180…… 27，4，100，170…… 26，5，100，160…… 25，6，100，150…… 24，7，100，140…… 23，1，100，130…… 22，3，100，120…… 需求：取最...
Hive_JDBC.zip_hive java_hive jdbc_hive jdbc pom_java hive_maven连
09-23
在大数据处理领域，Apache Hive是一个基于Hadoop的数据仓库工具，它允许用户使用SQL（HQL，Hive Query Language）查询存储在Hadoop集群中的大型数据集。Hive JDBC（Java Database Connectivity）是Hive提供的一种...
test_hive.rar_ThriftHive.php_hive_hive php_php hive_php hive Thr
09-21
标题中的“test_hive.rar_ThriftHive.php_hive_hive php_php hive_php hive Thr”暗示了我们讨论的主题是关于使用PHP通过Thrift接口与Hive数据仓库进行交互的一个库，具体来说，是一个名为“ThriftHive.php”的文件...
TPC-H_on_Hive_2009-08-14.tar.gz
06-06
Hive是Apache软件基金会开发的一个数据仓库工具，它允许用户使用SQL（HQL，Hive Query Language）对存储在Hadoop分布式文件系统（HDFS）中的大规模数据进行查询和分析。Hive将SQL语句转换为MapReduce任务，在Hadoop...
hive_jdbc_2.6.2.1002.zip
08-22
Hive 是由 Apache 软件基金会开发的一个数据仓库工具，它允许用户使用类 SQL 查询语言（HQL）来处理存储在分布式文件系统中的大规模数据。JDBC（Java Database Connectivity）则是 Java 平台的标准数据库连接接口，...
hive_medo_java_hive_
10-02
在IT行业中，Hive是一个基于Hadoop的数据仓库工具，它允许使用SQL（称为HQL，Hive Query Language）对大规模数据集进行分析。Hive由Facebook最初开发，并且现在是Apache软件基金会的一部分，广泛应用于大数据处理...
深入浅出Hive企业级架构优化、Hive Sql优化,视频
05-31
深入浅出Hive企业级架构优化、Hive Sql优化,视频！！！
HIveSQL面试题52：近一个月发布的视频中热度最高的top3视频【抖音面试题，不得不去吐槽的一个题目】
石榴姐yyds
04-17 1492
这道题源自于牛客网，题目本身没什么难度，但在牛客中通过率极低，原因是题目本身但表达很模糊，很多定义没有直接给出，靠面试者猜，造成了误解，如果面试遇到这种题目90%挂，因为你不能准确理解题意，需要反复和面试官确认，即使做出来了，最终也是失败，而这题竟然出自抖音，面试出题也太随意了，无力吐槽，看来面试有时候真的靠缘分，哈哈哈。。。。
HQL练习之谷粒影音
YellowXiuHui的博客
07-26 414
文章目录一、统计视频观看数Top101.思路1.SQL二、统计视频类别热度Top101.思路1.SQL三、统计出视频观看数最高的20个视频的所属类别以及类别包含Top20视频的个数1.思路1.SQL四、统计视频观看数Top50所关联视频的所属类别Rank1.思路五、统计每个类别中的视频热度Top10，以Music为例1.思路六、统计每个类别中视频流量Top10，以Music为例1.思路1.SQL七、统计上传视频最多的用户Top10以及他们上传的观看次数在前20的视频1.思路1.SQL八、统计每个类别视频观看
HQL：统计影音视频网站的常规指标，各种TopN指标
m0_38109926的博客
08-23 1509
统计影音视频网站的常规指标，各种TopN指标： – 统计视频观看数Top10 – 统计视频类别热度Top10（类别热度：类别下的总视频数） – 统计出视频观看数最高的20个视频的所属类别以及类别包含Top20视频的个数 – 统计视频观看数Top50所关联视频的所属类别Rank – 统计每个类别中的视频热度Top10,以Music为例（视频热度：视频观看数） – 统计每个类别视频观看数Top10 – 统计上传视频最多的用户Top10以及他们上传的视频观看次数在前20的视频 需要准备的表 创建外部数据表：m
MySQL面试题：近一个月发布的视频中热度最高的top3视频
weixin_46429290的博客
05-02 1211
近一个月发布的视频中热度最高的top3视频 内容目录近一个月发布的视频中热度最高的top3视频1.题目的几点注意项：2.需要计算的值：3.逻辑过程：4.代码： 题目：现有用户-视频互动表tb_user_video_loguid-用户ID, video_id-视频ID, start_time-开始观看时间, end_time-结束观看时间, if_follow-是否关注, if_like-是否点赞, if_retweet-是否转发, comment_id-评论ID） 短视频信息表tb_video_info（v
hive 聚合函数 count 的区别
heqingcool的博客
06-03 332
针对于这个问题，我们来实际操作得出结论： 建表： CREATE TABLE test_a( id int, name string ) ROW FORMAT DELIMITED FIELDS TERMINATED BY '\t'; 生成7000003 条数据，其中7000000万条是null值，3条是有数据的 1 name1 2 name2 3 name3 \N name1 ...... \N name7000000 用 count(*) 查询 hive (panniu)> sel
hive中count(distinct) 的原理
u011250186的博客
06-17 3074
目录 count（distinct id）的原理 count（distinct id）的解决方案 参考博客： https://blog.csdn.net/oracle8090/article/details/80760233 回到顶部 count（distinct id）的原理 count（distinct id）从执行计划上面来看：只有一个reducer任务（即使你设置reducer任务为100个，实际上也没有用），所有的id都 会聚集到同一个reducer任务进行去重然后在..
读懂简单的hive执行计划-explain计划
huobumingbai1234的博客
02-13 565
对于简单的hivesql，看懂执行计划能细致的知道怎么优化 对于如下这一段简单的sql，看下explain出来的内容 select prov_id ,deep ,count(1) as num from dim.dim_city where prov_id = 110000 and deep = 1 group by prov_id ,deep ; 执行计划 //描述任务之间的依赖关系 STAGE DEPENDENCIES: S
hive视频教程|Hive入门及实战演练（2017版本）
dengluyhu的博客
04-18 3112
Hive入门及实战演练（2017版本） 网盘地址：https://pan.baidu.com/s/1XjVARW7-CrfmZNPmwJDcZQ 密码：cts9 备用地址（腾讯微云）：https://share.weiyun.com/5rDivzP 密码：xsdfyq hive是基于Hadoop的一个数据仓库工具，可以将结构化的数据文件映射为一张数据库表，并提供简单的sql查询功能，...
阐述Hive的HQL语言和SQL语言的异同
最新发布
10-22
Hive的HQL语言和SQL语言有一些异同点： 1.语法不同：HQL语法是类似SQL的语法，但是有一些不同的关键字和函数。例如，Hive中使用的关键字包括TRANSFORM、CLUSTER BY和DISTRIBUTE BY等，而SQL中则没有这些关键字。 2....
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值