Hive：Spark中如何实现将rdd结果插入到hive1.3.1表中
时间： 07:13:33
&&&& 阅读：1427
&&&& 评论：
&&&& 收藏：0
标签：&&&&&&&&&&&&&&&&&&&&&&&&&&&
DataFrame写入hive API：
registerTempTable函数是创建spark临时表
insertInto函数是向表中写入数据，可以看出此函数不能指定数据库和分区等信息，不可以直接进行写入。
向hive数据仓库写入数据必须指定数据库，hive数据表建立可以在hive上建立，或者使用hiveContext.sql（&create table ...."）
case class Person(name:String,col1:Int,col2:String)
def main(args:Array[String]){
val sc = new org.apache.spark.SparkContext
val hiveContext = new org.apache.spark.sql.hive.HiveContext(sc)
import hiveContext.implicits._
hiveContext.sql("use DataBaseName")
val data = sc.textFile("path").map(x=&x.split("\\s+")).map(x=&Person(x(0),x(1).toInt,x(2)))
data.toDF()insertInto("tableName")
&将DataFrame数据写入hive指定数据表的分区中
hive数据表建立可以在hive上建立，或者使用hiveContext.sql（&create table ...."）
使用saveAsTable时数据存储格式有限，默认格式为parquet，可以指定为json，如果有其他格式指定，尽量使用语句来建立hive表。
将数据写入分区表的思路是：首先将DataFrame数据写入临时表，之后是由hiveContext.sql语句将数据写入hive分区表中。具体操作如下：
case class Person(name:String,col1:Int,col2:String)
def main(args:Array[String]):Unit={
val sc = new org.apache.spark.SparkContext
val hiveContext = new org.apache.spark.sql.hive.HiveContext(sc)
import hiveContext.implicits._
hiveContext.sql("use DataBaseName")
val data = sc.textFile("path").map(x=&x.split("\\s+")).map(x=&Person(x(0),x(1).toInt,x(2)))
data.toDF().registerTempTable("table1")
hiveContext.sql("insert into table2 partition(date=‘‘) select name,col1,col2 from table1")
声明本文转自：http://www.aboutyun.com/thread-.html
&标签：&&&&&&&&&&&&&&&&&&&&&&&&&&&原文：http://www.cnblogs.com/yy3b2007com/p/6082048.html
教程昨日排行
&&国之画&&&& &&&&&&
&& &&&&&&&&&&&&&&
鲁ICP备号-4
打开技术之扣，分享程序人生！Hive中小表与大表关联(join)的性能分析
经常看到一些Hive优化的建议中说当小表与大表做关联时，把小表写在前面，这样可以使Hive的关联速度更快，提到的原因都是说因为小表可以先放到内存中，然后大表的每条记录再去内存中检测，最终完成关联查询。这样的原因看似合理，但是仔细推敲，又站不住脚跟。
多小的表算小表？如果所谓的小表在内存中放不下怎么办？我用2个只有几条记录的表做关联查询，这应该算是小表了，在查看reduce的执行日志时依然是有写磁盘的操作的。实际上reduce在接收全部map的输出后一定会有一个排序所有键值对并合并写入磁盘文件的操作。写入磁盘（spill）有可能是多次的，因此有可能会生成多个临时文件，但是最终都要合并成一个文件，即最终每一个reduce都只处理一个文件。
我做了一个实验，用1条记录的表和3亿多条记录的表做join，无论小表是放在join的前面还是join的后面，执行的时间几乎都是相同的。再去看reduce的执行日志，1条记录的表在join前或者join后两次查询的reduce日志几乎也是一摸一样的。如果按照上面的说法把join左侧的表放内存等待join右侧的表到内存中去检测，那么当3亿多条记录的表放在join左侧时，内存肯定是无法容下这么多记录的，势必要进行写磁盘的操作，那它的执行时间应该会比小表在join前时长很多才对，但事实并不是这样，也就说明了上面说到的原因并不合理。
事实上“把小表放在前面做关联可以提高效率”这种说法是错误的。正确的说法应该是“把重复关联键少的表放在join前面做关联可以提高join的效率。”
分析一下Hive对于两表关联在底层是如何实现的。因为不论多复杂的Hive查询，最终都要转化成mapreduce的JOB去执行，因此Hive对于关联的实现应该和mapreduce对于关联的实现类似。而mapreduce对于关联的实现，简单来说，是把关联键和标记是在join左边还是右边的标识位作为组合键(key)，把一条记录以及标记是在join左边还是右边的标识位组合起来作为值(value)。在reduce的shuffle阶段，按照组合键的关联键进行主排序，当关联键相同时，再按照标识位进行辅助排序。而在分区段时，只用关联键中的关联键进行分区段，这样关联键相同的记录就会放在同一个value
list中，同时保证了join左边的表的记录在value list的前面，而join右边的表的记录在value list的后面。
例如A join B ON (A.id = b.id) ，假设A表和B表都有1条id =
3的记录，那么A表这条记录的组合键是(3,0)，B表这条记录的组合键是(3,1)。排序时可以保证A表的记录在B表的记录的前面。而在reduce做处理时，把id=3的放在同一个value list中，形成 key = 3,value list = [A表id=3的记录,B表id=3的记录]
接下来我们再来看当两个表做关联时reduce做了什么。Reduce会一起处理id相同的所有记录。我们把value
list用数组来表示。
Reduce先读取第一条记录v[0],如果发现v[0]是B表的记录，那说明没有A表的记录，最终不会关联输出，因此不用再继续处理这个id了，读取v[0]用了1次读取操作。
如果发现v[0]到v[length-1]全部是A表的记录，那说明没有B表的记录，同样最终不会关联输出，但是这里注意，已经对value做了length次的读取操作。
例如A表id=3有1条记录，B表id=3有10条记录。首先读取v[0]发现是A表的记录，用了1次读取操作。然后再读取v[1]发现是B表的操作，这时v[0]和v[1]可以直接关联输出了，累计用了2次操作。这时候reduce已经知道从v[1]开始后面都是B
表的记录了，因此可以直接用v[0]依次和v[2],v[3]……v[10]做关联操作并输出，累计用了11次操作。
换过来，假设A表id=3有10条记录，B表id=3有1条记录。首先读取v[0]发现是A表的记录，用了1次读取操作。然后再读取v[1]发现依然是A表的记录，累计用了2次读取操作。以此类推，读取v[9]时发现还是A表的记录，累计用了10次读取操作。然后读取最后1条记录v[10]发现是B表的记录，可以将v[0]和v[10]进行关联输出，累计用了11次操作。接下来可以直接把v[1]~v[9]分别与v[10]进行关联输出，累计用了20次操作。
再复杂一点，假设A表id=3有2条记录，B表id=3有5条记录。首先读取v[0]发现是A表的记录，用了1次读取操作。然后再读取v[1]发现依然是A表的记录，累计用了2次读取操作。然后读取v[2]发现是B表的记录，此时v[0]和v[2]可以直接关联输出，累计用了3次操作。接下来v[0]可以依次和v[3]~v[6]进行关联输出，累计用了7次操作。接下来v[1]再依次和v[2]~v[6]进行关联输出，累计用了12次操作。
把5的例子调过来，假设A表id=3有5条记录，B表id=3有2条记录。先读取v[0]发现是A表的记录，用了1次读取操作。然后再读取v[1]发现依然是A表的记录，累计用了2次读取操作。以此类推，读取到v[4]发现依然是A表的记录，累计用了5次读取操作。接下来读取v[5]，发现是B表的记录，此时v[0]和v[5]可以直接关联输出，累计用了6次操作。然后v[0]和v[6]进行关联输出，累计用了7次操作。然后v[1]分别与v[5]、v[6]关联输出，累计用了9次操作。V[2]
分别与v[5]、v[6]关联输出，累计用了11次操作。以此类推，最后v[4] 分别与v[5]、v[6]关联输出，累计用了15次操作。
额外提一下，当reduce检测A表的记录时，还要记录A表同一个key的记录的条数，当发现同一个key的记录个数超过hive.skewjoin.key的值（默认为1000000）时，会在reduce的日志中打印出该key，并标记为倾斜的关联键。
最终得出的结论是：写在关联左侧的表每有1条重复的关联键时底层就会多1次运算处理。
假设A表有一千万个id，平均每个id有3条重复值，那么把A表放在前面做关联就会多做三千万次的运算处理，这时候谁写在前谁写在后就看出性能的差别来了。
没有更多推荐了，hive导入数据的4种方法及示例代码_百度文库
您的浏览器Javascript被禁用，需开启后体验完整功能，
享专业文档下载特权
&赠共享文档下载特权
&10W篇文档免费专享
&每天抽奖多种福利
两大类热门资源免费畅读
续费一年阅读会员，立省24元！
hive导入数据的4种方法及示例代码
&&hive导入数据的4种方法及示例代码
阅读已结束，下载本文需要
想免费下载本文？
定制HR最喜欢的简历
下载文档到电脑，同时保存到云知识，更方便管理
加入VIP
还剩5页未读，
定制HR最喜欢的简历
你可能喜欢声明：现大部分文章为寻找问题时在网上相互转载，在此博客中做个记录，方便自己也方便有类似问题的朋友，故原出处已不好查到，如有侵权，请发邮件表明文章和原出处地址，我一定在文章中注明。谢谢。
随笔- 493&
评论- 104&
&&&&&&&&&&&
Hive是将符合SQL语法的字符串解析生成可以在Hadoop上执行的MapReduce的工具。使用Hive尽量按照分布式计算的一些特点来设计sql，和传统关系型数据库有区别，
所以需要去掉原有关系型数据库下开发的一些固有思维。
基本原则：
1：尽量尽早地过滤数据，减少每个阶段的数据量,对于分区表要加分区，同时只选择需要使用到的字段
select ... from A
on A.key = B.key
where A.userid&10
&&&&&and B.userid&10
&&&&&& &and A.dt=''
&&&&&& &and B.dt='';
应该改写为：
select .... from (select .... from A
&&&&&&&&&&&&&&&&&&where dt=''
&&&&&&&&&&&&&&&&&&&&&&&&&&& &&&&&&& and userid&10
&&&&&&&&&&&&&&&&&&&&&&&&&&& & ) a
join ( select .... from B
&&&&&&&where dt=''
&&&&&&&&&&&&&&&&&&&& and userid & 10&&&
on a.key = b.
2、对历史库的计算经验& (这项是说根据不同的使用目的优化使用方法)
&&&历史库计算和使用，分区
3：尽量原子化操作，尽量避免一个SQL包含复杂逻辑
可以使用中间表来完成复杂的逻辑& &
4 jion操作 & 小表要注意放在join的左边（目前TCL里面很多都小表放在join的右边）。
否则会引起磁盘和内存的大量消耗
5：如果union all的部分个数大于2，或者每个union部分数据量大，应该拆成多个insert into 语句，实际测试过程中，执行时间能提升50%
insert overwite table tablename partition (dt= ....)
select ..... from (
&&&&&&&&&&&&&&&&&&&select ... from A
&&&&&&&&&&&&&&&&&&&union all
&&&&&&&&&&&&&&&&&&&select ... from B
&&&&&&&&&&&&&&&&&& union all
&&&&&&&&&&&&&&&&&&&select ... from C
&&&&&&&&&&&&&&&&&&&&&&&&&&& &&&) R
where ...;
可以改写为：
insert into table tablename partition (dt= ....)
select .... from A
WHERE ...;
insert into table tablename partition (dt= ....)
select .... from B
WHERE ...;
insert into table tablename partition (dt= ....)
select .... from C
WHERE ...;&
5：写SQL要先了解数据本身的特点，如果有join ,group操作的话，要注意是否会有数据倾斜
如果出现数据倾斜，应当做如下处理：
set hive.exec.reducers.max=200;
set mapred.reduce.tasks= 200;---增大Reduce个数
set hive.groupby.mapaggr.checkinterval=100000 ;--这个是group的键对应的记录条数超过这个值则会进行分拆,值根据具体数据量设置
set hive.groupby.skewindata= --如果是group by过程出现倾斜 应该设置为true
set hive.skewjoin.key=100000; --这个是join的键对应的记录条数超过这个值则会进行分拆,值根据具体数据量设置
set hive.optimize.skewjoin=--如果是join 过程出现倾斜 应该设置为true
(1)& 启动一次job尽可能的多做事情，一个job能完成的事情,不要两个job来做
&通常来说前面的任务启动可以稍带一起做的事情就一起做了,以便后续的多个任务重用,与此紧密相连的是模型设计,好的模型特别重要.
(2)&合理设置reduce个数
reduce个数过少没有真正发挥hadoop并行计算的威力，但reduce个数过多，会造成大量小文件问题，数据量、资源情况只有自己最清楚，找到个折衷点,
(3)&使用hive.exec.parallel参数控制在同一个sql中的不同的job是否可以同时运行，提高作业的并发
2、让服务器尽量少做事情，走最优的路径，以资源消耗最少为目标
(1) 注意join的使用
若其中有一个表很小使用map join，否则使用普通的reduce join，注意hive会将join前面的表数据装载内存,所以较小的一个表在较大的表之前,减少内存资源的消耗
(2)注意小文件的问题
在hive里有两种比较常见的处理办法
第一是使用Combinefileinputformat，将多个小文件打包作为一个整体的inputsplit，减少map任务数
set&mapred.max.split.size=;
set&mapred.min.split.size.per.node=
set&&Mapred.min.split.size.per.rack=
set&hive.input.format=org.apache.hadoop.hive.ql.io.CombineHiveInputFormat
第二是设置hive参数，将额外启动一个MR Job打包小文件
hive.merge.mapredfiles&=&false&是否合并&Reduce&输出文件，默认为&False&
&hive.merge.size.per.task&=&256*&合并文件的大小&
(3)注意数据倾斜
在hive里比较常用的处理办法
第一通过hive.groupby.skewindata=true控制生成两个MR Job,第一个MR Job Map的输出结果随机分配到reduce做次预汇总,减少某些key值条数过多某些key条数过小造成的数据倾斜问题
第二通过hive.map.aggr&=&true(默认为true)在Map端做combiner,假如map各条数据基本上不一样, 聚合没什么意义，做combiner反而画蛇添足,hive里也考虑的比较周到通过参数hive.groupby.mapaggr.checkinterval&=&100000 (默认)hive.map.aggr.hash.min.reduction=0.5(默认),预先取100000条数据聚合,如果聚合后的条数/.5，则不再聚合
(4)善用multi insert,union all
multi insert适合基于同一个源表按照不同逻辑不同粒度处理插入不同表的场景，做到只需要扫描源表一次，job个数不变，减少源表扫描次数
union all用好，可减少表的扫描次数，减少job的个数,通常预先按不同逻辑不同条件生成的查询union all后，再统一group by计算,不同表的union all相当于multiple inputs,同一个表的union all,相当map一次输出多条
(5) 参数设置的调优
集群参数种类繁多,举个例子比如
可针对特定job设置特定参数,比如jvm重用,reduce&copy线程数量设置(适合map较快，输出量较大)
如果任务数多且小，比如在一分钟之内完成，减少task数量以减少任务初始化的消耗。可以通过配置JVM重用选项减少task的消耗
-----------------------------------------------------------
一、控制Hive中Map和reduce的数量
Hive中的sql查询会生成执行计划，执行计划以MapReduce的方式执行，那么结合数据和集群的大小，map和reduce的数量就会影响到sql执行的效率。
除了要控制Hive生成的Job的数量，也要控制map和reduce的数量。
1、&map的数量，通常情况下和split的大小有关系，之前写的一篇blog&map和reduce的数量是如何定义的&有描述。
&hive中默认的hive.input.format是org.apache.hadoop.hive.ql.io.CombineHiveInputFormat，对于combineHiveInputFormat,它的输入的map数量
由三个配置决定，
mapred.min.split.size.per.node， 一个节点上split的至少的大小
mapred.min.split.size.per.rack 一个交换机下split至少的大小
mapred.max.split.size 一个split最大的大小
它的主要思路是把输入目录下的大文件分成多个map的输入, 并合并小文件, 做为一个map的输入. 具体的原理是下述三步:
a、根据输入目录下的每个文件,如果其长度超过mapred.max.split.size,以block为单位分成多个split(一个split是一个map的输入),每个split的长度都大于mapred.max.split.size, 因为以block为单位, 因此也会大于blockSize, 此文件剩下的长度如果大于mapred.min.split.size.per.node, 则生成一个split, 否则先暂时保留.
b、现在剩下的都是一些长度效短的碎片,把每个rack下碎片合并, 只要长度超过mapred.max.split.size就合并成一个split, 最后如果剩下的碎片比mapred.min.split.size.per.rack大, 就合并成一个split, 否则暂时保留.
c、把不同rack下的碎片合并, 只要长度超过mapred.max.split.size就合并成一个split, 剩下的碎片无论长度, 合并成一个split.
举例: mapred.max.split.size=1000
mapred.min.split.size.per.node=300
mapred.min.split.size.per.rack=100
输入目录下五个文件,rack1下三个文件,长度为, rack2下两个文件,长度为1010,80. 另外blockSize为500.
经过第一步, 生成五个split: 00,499,1000. 剩下的碎片为rack1下:50,10; rack2下10:80
由于两个rack下的碎片和都不超过100, 所以经过第二步, split和碎片都没有变化.
第三步,合并四个碎片成一个split, 长度为150.
如果要减少map数量, 可以调大mapred.max.split.size, 否则调小即可.
其特点是: 一个块至多作为一个map的输入，一个文件可能有多个块，一个文件可能因为块多分给做为不同map的输入， 一个map可能处理多个块，可能处理多个文件。
2、&reduce数量
可以在hive运行sql的时，打印出来，如下：
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&
reduce数量由以下三个参数决定，
mapred.reduce.tasks(强制指定reduce的任务数量)
hive.exec.reducers.bytes.per.reducer（每个reduce任务处理的数据量，默认为G）
hive.exec.reducers.max（每个任务最大的reduce数，默认为999）
计算reducer数的公式很简单N=min( hive.exec.reducers.max&，总输入数据量/ hive.exec.reducers.bytes.per.reducer&)
& 只有一个reduce的场景：
& a、没有group by 的汇总
& b、order by
& c、笛卡尔积
二、join和Group的优化
& & & & 对于普通的join操作，会在map端根据key的hash值，shuffle到某一个reduce上去，在reduce端做join连接操作，内存中缓存join左边的表，遍历右边的表，一次做join操作。所以在做join操作时候，将数据量多的表放在join的右边。
& & & &当数据量比较大，并且key分布不均匀，大量的key都shuffle到一个reduce上了，就出现了数据的倾斜。
& & &&& & & &对于Group操作，首先在map端聚合，最后在reduce端坐聚合，hive默认是这样的，以下是相关的参数& & & & && hive..aggr = true是否在 Map 端进行聚合，默认为 True& & & & & hive.groupby.mapaggr.checkinterval = 100000在 Map 端进行聚合操作的条目数目
& & & &对于join和Group操作都可能会出现数据倾斜。
& & & & 以下有几种解决这个问题的常见思路
& & & 1、参数hive.groupby.skewindata = true,解决数据倾斜的万能钥匙，查询计划会有两个 MR&。第一个 MR Job 中，Map 的输出结果集合会随机分布到 Reduce 中，每个 Reduce 做部分聚合操作，并输出结果，这样处理的结果是相同的 Group By Key 有可能被分发到不同的 Reduce 中，从而达到负载均衡的目的；第二个 MR Job 再根据预处理的数据结果按照 Group By Key 分布到 Reduce 中（这个过程可以保证相同的 Group By Key 被分布到同一个 Reduce 中），最后完成最终的聚合操作。
& & & 2、where的条件写在join里面，使得减少join的数量（经过map端过滤，只输出复合条件的）
& & & 3、mapjoin方式，无reduce操作，在map端做join操作（map端cache小表的全部数据），这种方式下无法执行Full/RIGHT OUTER join操作
& & & 4、对于count(distinct)操作，在map端以group by的字段和count的字段联合作为key，如果有大量相同的key，那么会存在数据倾斜的问题& & & 5、数据的倾斜还包括，大量的join连接key为空的情况，空的key都hash到一个reduce上去了，解决这个问题，最好把空的key和非空的key做区分& & & & &空的key不做join操作。
& &当然有的hive操作，不存在数据倾斜的问题，比如数据聚合类的操作，像sum、count，因为已经在map端做了聚合操作了，到reduce端的数据相对少一些，所以不存在这个问题。
四、小文件的合并
& & & &大量的小文件导致文件数目过多，给HDFS带来压力，对hive处理的效率影响比较大，可以合并map和reduce产生的文件
& & & & &&& hive.merge.mapfiles = true是否和并 Map 输出文件，默认为 True& & & & & & hive.merge.mapredfiles =&是否合并 Reduce 输出文件，默认为 False& & & & && hive.merge.size.per.task = 256*合并文件的大小
五、in/exists（not）
& & & & &通过
六、分区裁剪
& & & & &通过在条件中指定分区，来限制数据扫描的范围，可以极大提高查询的效率
& & & & order by 排序，只存在一个reduce，这样效率比较低。
& & & & 可以用sort by操作,通常结合distribute by使用做reduce分区键
阅读(...) 评论()
声明：现大部分文章为寻找问题时在网上相互转载，在此博客中做个记录，方便自己也方便有类似问题的朋友，故原出处已不好查到，如有侵权，请发邮件表明文章和原出处地址，我一定在文章中注明。谢谢。本章将介绍如何创建一个表以及如何将数据插入。创造表的约定在Hive中非常类似于使用SQL创建表。
CREATE TABLE语句
Create Table是用于在Hive中创建表的语句。语法和示例如下：
CREATE [TEMPORARY] [EXTERNAL] TABLE [IF NOT EXISTS] [db_name.] table_name
[(col_name data_type [COMMENT col_comment], ...)]
[COMMENT table_comment]
[ROW FORMAT row_format]
[STORED AS file_format]
假设需要使用CREATE TABLE语句创建一个名为employee表。下表列出了employee表中的字段和数据类型：
Designation
下面的数据是一个注释，行格式字段，如字段终止符，行终止符，并保存的文件类型。
COMMENT &Employee details&
FIELDS TERMINATED BY &\t&
LINES TERMINATED BY &\n&
STORED IN TEXT FILE
下面的查询创建使用上述数据的表名为 employee。
hive& CREATE TABLE IF NOT EXISTS employee ( eid int, name String,
& salary String, destination String)
& COMMENT &Employee details&
& ROW FORMAT DELIMITED
& FIELDS TERMINATED BY &\t&
& LINES TERMINATED BY &\n&
& STORED AS TEXTFILE;
如果添加选项IF NOT EXISTS，Hive 忽略大小写，万一表已经存在的声明。
成功创建表后，能看到以下回应：
Time taken: 5.905 seconds
以下是使用JDBC程序来创建表给出的一个例子。
import java.sql.SQLException;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.Statement;
import java.sql.DriverManager;
public class HiveCreateTable {
private static String driverName = &org.apache.hadoop.hive.jdbc.HiveDriver&;
public static void main(String[] args) throws SQLException {
// Register driver and create driver instance
Class.forName(driverName);
// get connection
Connection con = DriverManager.getConnection(&jdbc:hive://localhost:10000/userdb&, &&, &&);
// create statement
Statement stmt = con.createStatement();
// execute statement
stmt.executeQuery(&CREATE TABLE IF NOT EXISTS &
+& employee ( eid int, name String, &
+& salary String, destignation String)&
+& COMMENT &Employee details&&
+& ROW FORMAT DELIMITED&
+& FIELDS TERMINATED BY &\t&&
+& LINES TERMINATED BY &\n&&
+& STORED AS TEXTFILE;&);
System.out.println(& Table employee created.&);
con.close();
将该程序保存在一个名为HiveCreateDb.java文件。下面的命令用于编译和执行这个程序。
$ javac HiveCreateDb.java
$ java HiveCreateDb
Table employee created.
LOAD DATA语句
一般来说，在SQL创建表后，我们就可以使用INSERT语句插入数据。但在Hive中，可以使用LOAD DATA语句插入数据。
同时将数据插入到Hive，最好是使用LOAD DATA来存储大量记录。有两种方法用来加载数据：一种是从本地文件系统，第二种是从Hadoop文件系统。
加载数据的语法如下：
LOAD DATA [LOCAL] INPATH 'filepath' [OVERWRITE] INTO TABLE tablename
[PARTITION (partcol1=val1, partcol2=val2 ...)]
LOCAL是标识符指定本地路径。它是可选的。
OVERWRITE 是可选的，覆盖表中的数据。
PARTITION 这是可选的
我们将插入下列数据到表中。在/home/user目录中名为sample.txt的文件。
Technical manager
Proof reader
Masthanvali 40000
Technical writer
下面的查询加载给定文本插入表中。
hive& LOAD DATA LOCAL INPATH '/home/user/sample.txt'
& OVERWRITE INTO TABLE employee;
下载成功完成，能看到以下回应：
Time taken: 15.905 seconds
下面给出的是JDBC程序将给定的数据加载到表中。
import java.sql.SQLException;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.Statement;
import java.sql.DriverManager;
public class HiveLoadData {
private static String driverName = &org.apache.hadoop.hive.jdbc.HiveDriver&;
public static void main(String[] args) throws SQLException {
// Register driver and create driver instance
Class.forName(driverName);
// get connection
Connection con = DriverManager.getConnection(&jdbc:hive://localhost:10000/userdb&, &&, &&);
// create statement
Statement stmt = con.createStatement();
// execute statement
stmt.executeQuery(&LOAD DATA LOCAL INPATH '/home/user/sample.txt'& + &OVERWRITE INTO TABLE&);
System.out.println(&Load Data into employee successful&);
con.close();
将该程序保存在一个名为HiveLoadData.java文件。使用下面的命令来编译和执行这个程序。
$ javac HiveLoadData.java
$ java HiveLoadData
Load Data into employee successful
易百教程移动端：请扫描本页面底部(右侧)二维码并关注微信公众号，回复："教程" 选择相关教程阅读或直接访问：http://m.yiibai.com 。
上一篇：下一篇：
加QQ群啦，易百教程官方技术学习群
注意：建议每个人选自己的技术方向加群，同一个QQ最多限加3个群。
Java技术群：
（人数：2000，等级：LV5，免费：否）
MySQL/SQL群：
（人数：2000，等级：LV5，免费：否）
大数据开发群：
（人数：2000，等级：LV5，免费：否）
Python技术群：
（人数：2000，等级：LV5，免费：否）
人工智能深度学习：
（人数：2000，等级：LV5，免费：否）
测试工程师(新群)：
（人数：1000，等级：LV1，免费：是）
前端技术群(新群)：
（人数：1000，等级：LV1，免费：是）
C/C++技术(新群)：
（人数：1000，等级：LV1，免费：是）
Node.js技术(新群)：
（人数：1000，等级：LV1，免费：是）
PostgreSQL数据库（新群）：
（人数：1000，等级：LV1，免费：否）
Linux技术：
（人数：2000，等级：LV5，免费：否）
PHP开发者：
（人数：2000，等级：LV5，免费：是）
Oracle数据库：
（人数：2000，等级：LV5，免费：是）
C#/ASP.Net开发者：
（人数：2000，等级：LV5，免费：是）
数据分析师：
（人数：1000，等级：LV1，免费：是）R语言，Matlab语言等技术}