Hive為什么這么受歡迎？看完Hive架構以及應用介紹，你就明白了！

作者：Python工程師 2020-04-26 10:52:34

Hive究竟是什么，為什么在Hadoop家族中占有這么重要的地位，本篇文章將圍繞Hive的體系結構(架構)、Hive的操作、Hive與Hbase的區別等對Hive進行全方面的闡述。

前言

Hive這個框架在Hadoop的生態體系結構中占有及其重要的地位，在實際的業務當中用的也非常多，可以說Hadoop之所以這么流行在很大程度上是因為Hive的存在。那么Hive究竟是什么，為什么在Hadoop家族中占有這么重要的地位，本篇文章將圍繞Hive的體系結構(架構)、Hive的操作、Hive與Hbase的區別等對Hive進行全方面的闡述。

在此之前，先給大家介紹一個業務場景，讓大家感受一下為什么Hive如此的受歡迎：

業務描述：統計業務表consumer.txt中北京的客戶有多少位?下面是相應的業務數據：

id      city    name    sex            
0001    beijing zhangli man  
0002    guizhou lifang  woman  
0003    tianjin wangwei man  
0004    chengde wanghe  woman  
0005    beijing lidong  man  
0006    lanzhou wuting  woman  
0007    beijing guona   woman  
0008    chengde houkuo  man

首先我先用大家所熟悉的MapReduce程序來實現這個業務分析，完整代碼如下：

package IT; 
 
import java.io.IOException; 
import java.net.URI; 
 
import org.apache.hadoop.conf.Configuration; 
import org.apache.hadoop.fs.FSDataInputStream; 
import org.apache.hadoop.fs.FileSystem; 
import org.apache.hadoop.fs.Path; 
import org.apache.hadoop.io.IOUtils; 
import org.apache.hadoop.io.LongWritable; 
import org.apache.hadoop.io.Text; 
import org.apache.hadoop.mapreduce.Job; 
import org.apache.hadoop.mapreduce.Mapper; 
import org.apache.hadoop.mapreduce.Reducer; 
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat; 
import org.apache.hadoop.mapreduce.lib.input.TextInputFormat; 
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat; 
import org.apache.hadoop.mapreduce.lib.output.TextOutputFormat; 
import org.apache.hadoop.mapreduce.lib.partition.HashPartitioner; 
 
public class Consumer 
{ 
    public static String path1 = "hdfs://192.168.80.80:9000/consumer.txt"; 
    public static String path2 = "hdfs://192.168.80.80:9000/dir"; 
    public static void main(String[] args) throws Exception 
    { 
          FileSystem fileSystem = FileSystem.get(new URI(path1) , new Configuration()); 
          if(fileSystem.exists(new Path(path2))) 
          { 
              fileSystem.delete(new Path(path2), true); 
          } 
           
          Job job = new Job(new Configuration(),"Consumer"); 
          FileInputFormat.setInputPaths(job, new Path(path1)); 
          job.setInputFormatClass(TextInputFormat.class); 
          job.setMapperClass(MyMapper.class); 
          job.setMapOutputKeyClass(Text.class); 
          job.setMapOutputValueClass(LongWritable.class); 
           
          job.setNumReduceTasks(1); 
          job.setPartitionerClass(HashPartitioner.class); 
             
          job.setReducerClass(MyReducer.class); 
          job.setOutputKeyClass(Text.class); 
          job.setOutputValueClass(LongWritable.class); 
          job.setOutputFormatClass(TextOutputFormat.class); 
          FileOutputFormat.setOutputPath(job, new Path(path2)); 
          job.waitForCompletion(true); 
          //查看執行結果 
          FSDataInputStream fr = fileSystem.open(new Path("hdfs://hadoop80:9000/dir/part-r-00000")); 
          IOUtils.copyBytes(fr, System.out, 1024, true); 
     } 
    public static class MyMapper extends Mapper<LongWritable, Text, Text, LongWritable> 
    {       
            public static long sum = 0L; 
            protected void map(LongWritable k1, Text v1,Context context) throws IOException, InterruptedException 
            { 
                  String[] splited = v1.toString().split("\t"); 
                  if(splited[1].equals("beijing")) 
                  { 
                      sum++; 
                  } 
            } 
            protected void cleanup(Context context)throws IOException, InterruptedException 
            { 
                  String str = "beijing"; 
                  context.write(new Text(str),new LongWritable(sum)); 
            } 
    } 
    public static class MyReducer extends Reducer<Text, LongWritable, Text, LongWritable> 
    { 
            protected void reduce(Text k2, Iterable<LongWritable> v2s,Context context)throws IOException, InterruptedException 
            { 
                  for (LongWritable v2 : v2s) 
                 { 
                     context.write(k2, v2); 
                 } 
            }    
    }    
}

MapReduce程序代碼運行結果如下：

從運行結果可以看出：在consumer.txt業務表中，北京的客戶共有三位。下面我們將用Hive來實現相同的功能，即統計業務表consumer.txt中北京的客戶有多少位?

Hive操作如下：

Hive運行結果如下：

OK 
beijing 3 
Time taken: 19.768 seconds, Fetched: 1 row(s)

到這里，是不是感覺Hive這個運行框架很神奇-----對于相同的業務邏輯只需要寫幾行Sql命令就可以獲取我們所需要的結果，這也恰恰是Hive為什么這么流行的原因，Hive的優勢主要體現在：

①Hive支持標準的SQL語法，免去了用戶編寫MapReduce程序的過程，大大減少了公司的開發成本

②Hive的出現可以讓那些精通SQL技能、但是不熟悉MapReduce 、編程能力較弱與不擅長Java語言的用戶能夠在HDFS大規模數據集上很方便地利用SQL 語言查詢、匯總、分析數據，畢竟精通SQL語言的人要比精通Java語言的多得多

③Hive是為大數據批量處理而生的，Hive的出現解決了傳統的關系型數據庫(MySql、Oracle)在大數據處理上的瓶頸

好了，上面通過一個簡單的小業務場景說明了Hive的巨大優勢，接下來將進入本篇文章的正題。

一：Hive體系結構(架構)的介紹

1、Hive的概念：

①Hive是為了簡化用戶編寫MapReduce程序而生成的一種框架，使用MapReduce做過數據分析的人都知道，很多分析程序除業務邏輯不同外，程序流程基本一樣。在這種情況下，就需要Hive這樣的用戶編程接口。Hive提供了一套類SQL的查詢語言，稱為QL，而在創造Hive框架的過程中之所以使用SQL實現Hive是因為大家對SQL語言非常的熟悉，轉換成本低，可以大大普及我們Hadoop用戶使用的范圍，類似作用的Pig就不是通過SQL實現的。

Hive是基于Hadoop的一個開源數據倉庫系統，可以將結構化的數據文件映射為一張數據庫表，并提供完整的sql查詢功能，Hive可以把SQL中的表、字段轉換為HDFS中的目錄、文件。

②Hive是建立在Hadoop之上的數據倉庫基礎構架、是為了減少MapReduce編寫工作的批處理系統，Hive本身不存儲和計算數據，它完全依賴于HDFS和MapReduce。Hive可以理解為一個客戶端工具，將我們的sql操作轉換為相應的MapReduce jobs，然后在Hadoop上面運行。

在開始為大家列舉的consumer.txt小業務當中，從編寫Sql到最后得出Beijing 3的分析結果實際上中間走的是MapReduce程序，只不過這個MapReduce程序不用用戶自己編寫，而是由Hive這個客戶端工具將我們的sql操作轉化為了相應的MapReduce程序，下面是我們運行sql命令時顯示的相關日志：

hive> select city,count(*) 
    > from t4     
    > where city='beijing' 
    > group by city; 
Total MapReduce jobs = 1 
Launching Job 1 out of 1 
Number of reduce tasks not specified. Estimated from input data size: 1 
In order to change the average load for a reducer (in bytes): 
  set hive.exec.reducers.bytes.per.reducer=<number> 
In order to limit the maximum number of reducers: 
  set hive.exec.reducers.max=<number> 
In order to set a constant number of reducers: 
  set mapred.reduce.tasks=<number> 
Starting Job = job_1478233923484_0902, Tracking URL = http://hadoop22:8088/proxy/application_1478233923484_0902/ 
Kill Command = /usr/local/hadoop/bin/hadoop job  -kill job_1478233923484_0902 
Hadoop job information for Stage-1: number of mappers: 1; number of reducers: 1 
2016-11-09 11:36:36,688 Stage-1 map = 0%,  reduce = 0% 
2016-11-09 11:36:42,018 Stage-1 map = 100%,  reduce = 0%, Cumulative CPU 1.21 sec 
2016-11-09 11:36:43,062 Stage-1 map = 100%,  reduce = 0%, Cumulative CPU 1.21 sec 
2016-11-09 11:36:44,105 Stage-1 map = 100%,  reduce = 0%, Cumulative CPU 1.21 sec 
2016-11-09 11:36:45,149 Stage-1 map = 100%,  reduce = 0%, Cumulative CPU 1.21 sec 
2016-11-09 11:36:46,193 Stage-1 map = 100%,  reduce = 0%, Cumulative CPU 1.21 sec 
2016-11-09 11:36:47,237 Stage-1 map = 100%,  reduce = 0%, Cumulative CPU 1.21 sec 
2016-11-09 11:36:48,283 Stage-1 map = 100%,  reduce = 0%, Cumulative CPU 1.21 sec 
2016-11-09 11:36:49,329 Stage-1 map = 100%,  reduce = 100%, Cumulative CPU 3.7 sec 
2016-11-09 11:36:50,384 Stage-1 map = 100%,  reduce = 100%, Cumulative CPU 3.7 sec 
MapReduce Total cumulative CPU time: 3 seconds 700 msec 
Ended Job = job_1478233923484_0902 
MapReduce Jobs Launched:  
Job 0: Map: 1  Reduce: 1   Cumulative CPU: 3.7 sec   HDFS Read: 419 HDFS Write: 10 SUCCESS 
Total MapReduce CPU Time Spent: 3 seconds 700 msec 
OK 
beijing 3 
Time taken: 19.768 seconds, Fetched: 1 row(s)

從日志可以看出，Hive將我們的sql命令解析成了相應的MapReduce任務，最后得到了我們的分析結果。

③Hive可以認為是MapReduce的一個封裝、包裝。Hive的意義就是在業務分析中將用戶容易編寫、會寫的Sql語言轉換為復雜難寫的MapReduce程序，從而大大降低了Hadoop學習的門檻，讓更多的用戶可以利用Hadoop進行數據挖掘分析。

為了讓大家容易理解Hive的實質-------“Hive就是一個SQL解析引擎，將SQL語句轉化為相應的MapReduce程序”這句話，博主用一個圖示進行示例：

從圖示可以看出，Hive從某種程度上講就是很多“SQL—MapReduce”框架的一個封裝，可以將用戶編寫的Sql語言解析成對應的MapReduce程序，最終通過MapReduce運算框架形成運算結果提交給Client。

2、Hive體系結構的介紹

下面是Hive的體系結構圖：

Hive的體系結構可以分為以下幾個部分：

①用戶接口：包括shell命令、Jdbc/Odbc和WebUi，其中最常用的是shell這個客戶端方式對Hive進行相應操作

②Hive解析器(驅動Driver)：Hive解析器的核心功能就是根據用戶編寫的Sql語法匹配出相應的MapReduce模板，形成對應的MapReduce job進行執行。

③Hive元數據庫(MetaStore)：Hive將表中的元數據信息存儲在數據庫中，如derby(自帶的)、Mysql(實際工作中配置的)，Hive中的元數據信息包括表的名字、表的列和分區、表的屬性(是否為外部表等)、表的數據所在的目錄等。Hive中的解析器在運行的時候會讀取元數據庫MetaStore中的相關信息。

在這里和大家說一下為什么我們在實際業務當中不用Hive自帶的數據庫derby，而要重新為其配置一個新的數據庫Mysql，是因為derby這個數據庫具有很大的局限性：derby這個數據庫不允許用戶打開多個客戶端對其進行共享操作，只能有一個客戶端打開對其進行操作，即同一時刻只能有一個用戶使用它，自然這在工作當中是很不方便的，所以我們要重新為其配置一個數據庫。

④Hadoop：Hive用HDFS進行存儲，用MapReduce進行計算-------Hive這個數據倉庫的數據存儲在HDFS中，業務實際分析計算是利用MapReduce執行的。

從上面的體系結構中可以看出，在Hadoop的HDFS與MapReduce以及MySql的輔助下，Hive其實就是利用Hive解析器將用戶的SQl語句解析成對應的MapReduce程序而已，即Hive僅僅是一個客戶端工具，這也是為什么我們在Hive的搭建過程中沒有分布與偽分布搭建的原因。(Hive就像是劉邦一樣，合理的利用了張良、韓信與蕭何的輔助，從而成就了一番大事!)

3、Hive的運行機制

Hive的運行機制如下圖所示：

Hive的運行機制正如圖所示：創建完表之后，用戶只需要根據業務需求編寫Sql語句，而后將由Hive框架將Sql語句解析成對應的MapReduce程序，通過MapReduce計算框架運行job，便得到了我們最終的分析結果。

在Hive的運行過程中，用戶只需要創建表、導入數據、編寫Sql分析語句即可，剩下的過程將由Hive框架自動完成，而創建表、導入數據、編寫Sql分析語句其實就是數據庫的知識了，Hive的運行過程也說明了為什么Hive的存在大大降低了Hadoop的學習門檻以及為什么Hive在Hadoop家族中占有著那么重要的地位。

二：Hive的操作

Hive的操作對于用戶來說實際上就是表的操作、數據庫的操作。下面我們將圍繞兩個方面進行介紹：

1、Hive的基本命令.

啟動hive命令行:

$>hive/bin/hive 
    $hive>show databases ;                              -- 顯式數據庫 
    $hive>create database mydb ;                        -- 創建數據庫 
    $hive>use mydb ;                                    -- 使用庫 
    $hive>create table custs(id int , name string) ;    -- 建表 
    $hive>desc custs ;                                  -- 查看表結構 
    $hive>desc formatted custs ;                        -- 查看格式化表結構 
    $hive>insert into custs(id,name) values(1,'tom');   -- 插入數據，轉成mr. 
    $hive>select * from custs ;                         -- 查詢，沒有mr 
    $hive>select * from custs order by id desc ;        -- 全排序，會生成mr. 
    $hive>exit ;                                        -- 退出終端 
 
 
查看mysql中的元信息: 
    select * from dbs ;                                 -- 存放庫信息 
    select * from tbls ;                                -- 存放表信息

2、Hive表------內部表、外部表、分區表的創建

所謂內部表就是普通表，創建語法格式為：

實際操作:

外部表(external table)的創建語法格式為：

注意：最后一行寫到的是目錄dir，文件就不用寫了，Hive表會自動到dir目錄下讀取所有的文件file

我在實際的操作過程當中發現，location關聯到的目錄下面必須都是文件，不能含有其余的文件夾，不然讀取數據的時候會報錯。

實際操作:

內部表與外部表的區別：

內部表在加載數據的過程中，實際數據會被移動到數據倉庫目錄中(hive.metastore.warehouse.dir),之后用戶對數據的訪問將會直接在數據倉庫目錄中完成;刪除內部表時，內部表中的數據和元數據信息會被同時刪除。
外部表在加載數據的過程中，實際數據并不會被移動到數據倉庫目錄中，只是與外部表建立一個鏈接(相當于文件的快捷方式一樣);刪除外部表時，僅刪除該鏈接。

補充：在工作中發現，對于外部表，即使hive中的表刪除了，但是在HDFS中表的location仍然存在。

分區表的概念：指的是我們的數據可以分區，即按照某個字段將文件劃分為不同的標準，分區表的創建是通過在創建表時啟用partitioned by來實現的。

分區表的創建語法格式為：

注意：分區表在加載數據的過程中要指定分區字段，否則會報錯，正確的加載方式如下：

load data local inpath ‘/usr/local/consumer.txt’ into table t1 partition (day=2) ;

其余的操作和內部表、外部表是一樣的。

實際操作:

參考2：

CREATE EXTERNAL TABLE `fdm_buffalo_3_5_task_exec_time`( 
  `task_id`      int COMMENT '任務id',  
  `task_version` string COMMENT '任務版本',  
  `exec_time`    string COMMENT '平均執行時長') 
PARTITIONED BY (  
  `dt` string) 
ROW FORMAT DELIMITED  
  FIELDS TERMINATED BY '\t'; 
 
 
實際: 
hive> show create table fdm_buffalo_3_5_task_exec_time; 
OK 
CREATE EXTERNAL TABLE `fdm_buffalo_3_5_task_exec_time`( 
  `task_id` int COMMENT '任務id',  
  `task_version` string COMMENT '任務版本',  
  `exec_time` string COMMENT '平均執行時長') 
PARTITIONED BY (  
  `dt` string) 
ROW FORMAT DELIMITED  
  FIELDS TERMINATED BY '\t'  
STORED AS INPUTFORMAT  
  'org.apache.hadoop.mapred.TextInputFormat'  
OUTPUTFORMAT  
  'org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat' 
LOCATION 
  'hdfs://ns5/user/dd_edw/fdm.db/fdm_buffalo_3_5_task_exec_time' 
TBLPROPERTIES ( 
  'mart_name'='dd_edw',  
  'transient_lastDdlTime'='1555384611') 
Time taken: 0.036 seconds, Fetched: 17 row(s)

3、將數據文件加載(導入)到Hive表中

在Hive中創建完表之后，我們隨后自然要向表中導入數據，但是在導入數據的時候和我們的傳統數據庫(MySql、Oracle)是不同的：Hive不支持一條一條的用insert語句進行插入操作，也不支持update的操作。Hive表中的數據是以load的方式，加載到建立好的表中。數據一旦導入，則不可修改。要么drop掉整個表，要么建立新的表，導入新的數據。

導入數據的語法格式為：

導入數據時要注意一下幾點：

local inpath表示從本地linux中向Hive表中導入數據，inpath表示從HDFS中向Hive表中導入數據
默認是向原Hive表中追加數據，overwrite表示覆蓋表中的原數據進行導入
partition是分區表特有的，而且在導入數據數據時是必須添加的，否則會報錯
load 操作只是單純的復制/移動操作，將數據文件復制/移動到 Hive 表對應的位置,即Hive 在加載數據的過程中不會對數據本身進行任何修改，而只是將數據內容復制或者移動到相應的表中

導入示例代碼：(注意overwrite的用法)

hive> load data local inpath "/home/dd_edw/zmy_project/task_relations.txt" overwrite into table fdm.chevrolet_buffalo_task_recusion_relations partition(dt='2019-05-28'); 
Loading data to table fdm.chevrolet_buffalo_task_recusion_relations partition (dt=2019-05-28) 
Moved: 'hdfs://ns5/user/dd_edw/fdm.db/chevrolet_buffalo_task_recusion_relations/dt=2019-05-28/task_relations.txt' to trash at: hdfs://ns5/user/dd_edw/.Trash/Current 
Moved: 'hdfs://ns5/user/dd_edw/fdm.db/chevrolet_buffalo_task_recusion_relations/dt=2019-05-28/task_relations_copy_1.txt' to trash at: hdfs://ns5/user/dd_edw/.Trash/Current 
Partition fdm.chevrolet_buffalo_task_recusion_relations{dt=2019-05-28} stats: [numFiles=1, numRows=0, totalSize=272475104, rawDataSize=0] 
OK 
Time taken: 3.381 seconds 
hive> dfs -ls hdfs://ns5/user/dd_edw/fdm.db/chevrolet_buffalo_task_recusion_relations/*/ ; 
Found 1 items 
-rwxr-xr-x   3 dd_edw dd_edw  272475104 2019-05-29 20:08 hdfs://ns5/user/dd_edw/fdm.db/chevrolet_buffalo_task_recusion_relations/dt=2019-05-28/task_relations.txt

4、Hive添加分區操作:

正確語句:

hive> ALTER TABLE fdm_buffalo_3_5_task_exec_time ADD IF NOT EXISTS PARTITION (dt='2019-04-15'); 
OK 
Time taken: 0.059 seconds

錯誤語句：

hive> alter table fdm_buffalo_3_5_task_exec_time if not exists add partition (dt='2019-04-15'); 
NoViableAltException(132@[]) 
        at org.apache.hadoop.hive.ql.parse.HiveParser.alterTableStatementSuffix(HiveParser.java:8170) 
        at org.apache.hadoop.hive.ql.parse.HiveParser.alterStatement(HiveParser.java:7635) 
        at org.apache.hadoop.hive.ql.parse.HiveParser.ddlStatement(HiveParser.java:2798) 
        at org.apache.hadoop.hive.ql.parse.HiveParser.execStatement(HiveParser.java:1731) 
        at org.apache.hadoop.hive.ql.parse.HiveParser.statement(HiveParser.java:1136) 
        at org.apache.hadoop.hive.ql.parse.ParseDriver.parse(ParseDriver.java:202) 
        at org.apache.hadoop.hive.ql.parse.ParseDriver.parse(ParseDriver.java:166) 
        at org.apache.hadoop.hive.ql.Driver.compile(Driver.java:411) 
        at org.apache.hadoop.hive.ql.Driver.compile(Driver.java:320) 
        at org.apache.hadoop.hive.ql.Driver.compileInternal(Driver.java:1372) 
        at org.apache.hadoop.hive.ql.Driver.runInternal(Driver.java:1425) 
        at org.apache.hadoop.hive.ql.Driver.run(Driver.java:1150) 
        at org.apache.hadoop.hive.ql.Driver.run(Driver.java:1093) 
        at org.apache.hadoop.hive.cli.CliDriver.processLocalCmd(CliDriver.java:241) 
        at org.apache.hadoop.hive.cli.CliDriver.processCmd(CliDriver.java:191) 
        at org.apache.hadoop.hive.cli.CliDriver.processLine(CliDriver.java:551) 
        at org.apache.hadoop.hive.cli.CliDriver.executeDriver(CliDriver.java:969) 
        at org.apache.hadoop.hive.cli.CliDriver.run(CliDriver.java:912) 
        at org.apache.hadoop.hive.cli.CliDriver.main(CliDriver.java:824) 
        at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method) 
        at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:57) 
        at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43) 
        at java.lang.reflect.Method.invoke(Method.java:606) 
        at org.apache.hadoop.util.RunJar.run(RunJar.java:221) 
        at org.apache.hadoop.util.RunJar.main(RunJar.java:136) 
FAILED: ParseException line 1:43 cannot recognize input near 'if' 'not' 'exists' in alter table statement

5、查看某個分區

desc formatted bdm.bdm_dispatch_1_d_task_da partition(dt='2019-07-14');

三：Hive與Hbase的區別

其實從嚴格意義上講，Hive與Hbase就不應該談區別，談區別的原因無非就是Hive與Hbase本身都涉及到了表的創建、向表中插入數據等等。所以我們希望找到Hive與Hbase的區別，但是為什么兩者談不上區別呢，原因如下：

根據上文分析，Hive從某種程度上講就是很多“SQL—MapReduce”框架的一個封裝，即Hive就是MapReduce的一個封裝，Hive的意義就是在業務分析中將用戶容易編寫、會寫的Sql語言轉換為復雜難寫的MapReduce程序。
Hbase可以認為是hdfs的一個包裝。他的本質是數據存儲，是個NoSql數據庫;hbase部署于hdfs之上，并且克服了hdfs在隨機讀寫方面的缺點。

因此若要問Hive與Hbase之前的區別，就相當于問HDFS與MapReduce之間的區別，而HDFS與MapReduce兩者之間談區別意義并不大。

但是當我們非要談Hbase與Hive的區別時，可以從以下幾個方面進行討論：

Hive和Hbase是兩種基于Hadoop的不同技術–Hive是一種類SQL的引擎，并且運行MapReduce任務，Hbase是一種在Hadoop之上的NoSQL 的Key/vale數據庫。當然，這兩種工具是可以同時使用的。就像用Google來搜索，用FaceBook進行社交一樣，Hive可以用來進行統計查詢，HBase可以用來進行實時查詢，數據也可以從Hive寫到Hbase，設置再從Hbase寫回Hive。

Hive適合用來對一段時間內的數據進行分析查詢，例如，用來計算趨勢或者網站的日志。Hive不應該用來進行實時的查詢。因為它需要很長時間才可以返回結果。

Hbase非常適合用來進行大數據的實時查詢。Facebook用Hive進行消息和實時的分析。它也可以用來統計Facebook的連接數。

責任編輯：未麗燕來源：今日頭條

Hive 運行數據庫