我们使用的HiveServer2的版本为0.13.1-cdh5.3.2，目前的任务使用Hive SQL构建，分为两种类型：手动任务（临时分析需求）、调度任务（常规分析需求），两者均通过我们的Web系统进行提交。以前两种类型的任务都被提交至Yarn中一个名称为&hive&的队列，为了避免两种类型的任务之间相互受影响以及并行任务数过多导致&hive&队列资源紧张，我们在调度系统中构建了一个任务缓冲区队列，所有被提交的任务（手动任务、调度任务）并不会直接被提交至集群，而是提交至这个缓冲区队列中，然后固定数目的工作者线程再将缓冲区队列的任务取出提交至集群执行。
这种运行模式在运行任务数不是很多的情况下尚且可行，一旦我们的常规分析需求变多，调度任务数也会随之增加，这时临时分析需求建立的手动任务就可能会影响调度任务的执行，这种影响主要表现在以下两个方面：
（1）手动任务与调度任务共用一个队列&hive&，而队列&hive&的资源分配主要是根据调度任务的资源消耗情况进行分配的，这样随机提交的手动任务与调度任务共同执行时，就可能会影响原有调度任务的执行速度；而且无法根据两种任务各自的特性选择合适的调度策略（如：FIFO、Fair）；
（2）手动任务的提交需要经过调度系统内部的缓冲区队列，如果调度任务比较多，则手动任务可能需要在缓冲区队列中等待很长的时间才能够提交至集群运行，而任务运行时所需资源需要与调度任务共享，执行时间无法保证，用户通常需要等待较长时间；
针对上述情况，我们对队列&hive&进行拆分：hive.temporary、mon，其中hive.temporary用于临时分析需求的手动任务，mon用于常规分析需求的调度任务，这样我们就可以根据业务的实际情况，为两者灵活的进行资源分配。
队列拆分之后，我们就有了如下思考：手动任务（临时分析需求）是否依然需要经过调度系统的缓冲区队列再提交至集群？
队列拆分一定程度上意味着资源的独立，亦即手动任务与调度任务之间做到了物理上的隔离，如果手动任务依然使用调度系统的缓冲区队列，则也必须是专门针对手动任务的队列；而手动任务是临时分析需求，不可能预留太多的资源给它，为了保证手动任务在可接受的时间内执行完成，我们必须限制队列&hive.temporary&可同时运行任务的数目，以此来保证正在运行的任务有足够的资源去执行；如果某个时间点提交给集群的手动任务超过队列&hive.temporary&可同时运行任务数目的限制，则它们会被暂时&堆积&在Yarn调度器的队列当中。
由此可见，我们并不需要再为手动任务在调度系统中建立专门的缓冲区队列，直接利用Yarn调度器的队列即可。我们可以直接将手动任务直接提交至集群，由Yarn调度器根据队列&hive.temporary&根据调度策略及目前队列资源使用情况决定是否运行任务。
因为现在的手动任务不经过调度系统的缓冲区队列直接提交至集群，则手动任务的提交可以不再受限于Web系统，用户可以通过Hive官方推荐的Beeline客户端直接提交Hive SQL。
这就涉及到本文的核心问题：Beeline连接HiveServer2后如何使用指定的队列（Yarn）运行Hive&SQL语句？
MapReduce运行队列的指定是通过配置（Configuration）属性&mapreduce.job.queuename&指定的。
大家可能首先想到的是通过&set mapreduce.job.queuename=queueName&的方式来选取运行队列，这在手动任务（临时分析需求）的场景下是不可取的，如前所述，我们为这类似的任务专门分配了相应的队列资源&hive.temporary&，我们必须能够保证用户通过Beeline连接HiveServer2后提交的Hive SQL语句运行在指定的队列&hive.temporary&中，而且用户无法随意更改运行队列，即无法随意更改属性&mapreduce.job.queuename&。
目前HiveServer2使用的权限控制策略为SQL&Standard&Based&Hive&Authorization和Storage&Based&Authorization&in&the&Metastore&Server。其中SQL&Standard&Based&Hive&Authorization会对Hive终端命令&set&做出限制：只能针对白名单（hive.security.authorization.sqlstd.confwhitelist）中列出的属性进行赋值。白名单默认包含一批属性，其中就包括&mapreduce.job.queuename&，我们需要通过配置文件hive-site.xml或者启动HiveServer2时通过参数&--hiveconf&设置白名单&hive.security.authorization.sqlstd.confwhitelist&的值，排除属性&mapreduce.job.queuename&，使得我们的用户通过Beeline连接至HiveServer2之后，无法随意更改&mapreduce.job.queuename&的值。
既然用户无法更改属性&mapreduce.job.queuename&，那么HiveServer2启动之后属性&mapreduce.job.queuename&必须具有一个默认值，即&hive.temporary&，这样用户通过Beeline连接HiveServer2之后提交的Hive SQL就会运行在队列&hive.temporary&中。那么，接下来的问题就是如果完成这个默认设定？
一般情况下，我们会这样认为，HiveServer2的运行至少涉及到两份配置文件：
（1）Hadoop：core-site.xml、hdfs-site.xml、mapred-site.xml、yarn-site.xml
（2）Hive：hive-site.xml
这些配置文件中的属性值都会&打包&到MapReduce任务的配置属性中去。我们自然会想到在mapred-site.xml或者hive-site.xml中指定&mapreduce.job.queuename&即可，然而实际验证之后发现情况并不是这样的。
（1）在hive-site.xml（mapred-site.xml）中指定&mapreduce.job.queuename&；
（2）测试指定值&test&是否生效；
我们发现通过Beeline使用账号&hdfs&连接至HiveServer2后，属性&mapreduce.job.queuename&的值被替换为&root.hdfs&，实际执行Hive SQL语句时也会发现相应的MapReduce任务被提交至队列&root.hdfs&。
网上也有针对此类情况的提问：
其中的一个解决方案如下：
其实质就是通过建立连接时的URL参数传递属性值。
但是这种方法对于我们没有用处，我们不可能强制我们的用户连接HiveServer2时都指定队列，但这个解决方案给了我们一个思路：既然我们可以通过&客户端&建立连接时初始化属性值，那么&服务端&接受连接时会不会也有初始化的操作？
通过对源代码以及日志输出的各种&DEBUG&，最终找到了问题所在。大家都知道，HiveServer2有一个&Session&的概念，就是每一个用户有自己的一个会话（&set&的作用就是在用户自己的会话中设置特定的属性值），用户会话之间相互隔离。根据我们的猜测，我们找到了HiveServer2 Session的实现类：org.apache.hive.service.cli.session.HiveSessionImpl.HiveSessionImpl，它的初始化（构造函数）就是&魔法&发生的地方，关键片段如下：
而且ConfVars.HIVE_SERVER2_MAP_FAIR_SCHEDULER_QUEUE的值默认为true，如下：
上述代码片段默认情况下肯定会被执行，也就是说HiveSession的构建过程涉及到了Hadoop Scheduler的具体使用。
refreshDefaultQueue的作用就是在可用的情况下为特定用户根据公平调度策略选取队列，其中可用的情况：
（1）MapReduce2；
（2）用户名不为空值；
（3）使用公平调度策略；
继续跟进代码，可以看到如下代码片段：
QueuePlacementPolicy assignAppToQueue的作用就是为用户分配队列的，其中YarnConfiguration.DEFAULT_QUEUE_NAME的值为default，MR2_JOB_QUEUE_PROPERTY的值为mapreduce.job.queuename，conf实际是HiveConf实例，我们在hive-site.xml或者mapred-site.xml中指定的mapreduce.job.queuename的值也就是在此处被覆盖的（注意：每一个用户会话中都保存着自己的conf）。
从上面的代码可以看出，最终是由某个QueuePlacementRule决定用户队列的，那么什么决定rules的呢？
其中FairSchedulerConfiguration.USER_AS_DEFAULT_QUEUE的值为yarn.scheduler.fair.user-as-default-queue，FairSchedulerConfiguration.DEFAULT_USER_AS_DEFAULT_QUEUE的值为true，也就是说默认情况下rules包含两个QueuePlacementRule实例：
（1）org.apache.hadoop.yarn.server.resourcemanager.scheduler.fair.QueuePlacementRule.Specified
如前所述，requestedQueue值为&default&，因此该rule返回值为&&（空字符串），继续下一个rule的队列选取。
（2）org.apache.hadoop.yarn.server.resourcemanager.scheduler.fair.QueuePlacementRule.User
该rule队列的选取规则特别简单：root. + 用户名。
这也就是上述验证过程中出现队列&root.hdfs&的原因所在。
综上所述，用户通过Beeline连接HiveServer2后的队列选取，默认情况下受公平调度策略的影响，如果想通过hive-site.xml或者mapred-site.xml中指定mapreduce.job.queuename，有一个非常简单的办法就是将属性值hive.server2.map.fair.scheduler.queue（ConfVars.HIVE_SERVER2_MAP_FAIR_SCHEDULER_QUEUE）置为false，可以在hive-site.xml中指定或或者启动HiveServer2时通过参数指定，这样HiveServer2队列的选取就不再受公平调度策略的影响。
版权所有 京ICP备号-2
迷上了代码！通过Hive提供的order by子句可以让最终的输出结果整体有序。但是因为Hive是基于Hadoop之上的，要生成这种整体有序的结果，就必须强迫Hadoop只利用一个Reduce来完成处理。这种方式的副作用就是回降低效率。
如果你不需要最终结果整体有序，你就可以使用sort by子句来进行排序。这种排序操作只保证每个Reduce的输出是有序的。如果你希望某些特定行被同一个Reduce处理，则你可以使用distribute子句来完成。比如：
表student（classNo，stuNo，score）数据如下：
C01& N0101&&&&& 82
C01& N0102&&&&& 59
C02& N0201&&&&& 81
C01& N0103&&&&& 65
C03& N0302&&&&& 92
C02& N0202&&&&& 82
C02& N0203&&&&& 79
C03& N0301&&&&& 56
C03& N0306&&&&& 72
我们希望按照成绩由低到高输出每个班级的成绩信息。执行以下语句：
Select classNo,stuNo,score from student distribute byclassN
输出结果为:
C02& N0203&&&&& 79
C02& N0201&&&&& 81
C02& N0202&&&&& 82
C03& N0301&&&&& 56
C03& N0306&&&&& 72
C03& N0302&&&&& 92
C01& N0102&&&&& 59
C01& N0103&&&&& 65
C01& N0101&&&&& 82
我们可以看到每一个班级里所有的学生成绩是有序的。因为同一个classNo的记录会被分发到一个单独的reduce处理，而同时sort by保证了每一个reduce的输出是有序的。
为了测试上例中的distribute by的效果，你应该首先设置足够多的reduce。比如上例中有3个不同的classNo，则我们需要设置reduce个数至少为3或更多。如果设置的reduce个数少于3，将会导致多个不同的classNo被分发到同一个reduce，从而不能产生你所期望的输出。设置命令如下：
set mapred.reduce.tasks = 3;
MapReduce脚本
如果我们需要在查询语句中调用外部脚本，比如Python，则我们可以使用transform，map，reduce等子句。
比如，我们希望过滤掉所有不及格的学生记录，只输出及格学生的成绩信息。
新建一个Python脚本文件score_pass.py，内容如下：
#! /usr/bin/env python
import sys
for line in sys.stdin:
&&&&&&&& (classNo,stuNo,score)= line.strip().split('\t')&&
&&&&&&&& ifint(score) &= 60:
&&&&&&&&&&&&&&&&&& print&%s\t%s\t%s& %(classNo,stuNo,score)
执行以下语句
add file /home/user/score_pass.
select transform(classNo,stuNo,score) using'score_pass.py' as classNo,stuNo,
输出结果为：
C01& N0101&&&&& 82
C02& N0201&&&&& 81
C01& N0103&&&&& 65
C03& N0302&&&&& 92
C02& N0202&&&&& 82
C02& N0203&&&&& 79
C03& N0306&&&&& 72
1) 以上Python脚本中，分隔符只能是制表符(\t)。同样输出的分隔符也必须为制表符。这个是有hive自身决定的，不能更改，不要尝试使用其他分隔符，否则会报错。同时需要调用strip函数，以去除掉行尾的换行符。（或者直接使用不带参数的line.split()代替。
2) 使用脚本前，先使用add file语句注册脚本文件，以便hive将其分发到Hadoop集群。
3) Transfom传递数据到Python脚本，as语句指定输出的列。
连接（join）
直接编程使用Hadoop的MapReduce是一件比较费时的事情。Hive则大大简化了这个操作。
内连接（inner join）
和SQL的内连相似。执行以下语句查询每个学生的编号和教师名：
Select a.stuNo,b.teacherName from student a join teacherb on a.classNo = b.classNo;
输出结果如下：
N0203&&&&& Sun
N0202&&&&& Sun
N0201&&&&& Sun
N0306&&&&& Wang
N0301&&&&& Wang
N0302&&&&& Wang
N0103&&&&& Zhang
N0102&&&&& Zhang
N0101&&&&& Zhang
数据文件内容请参照上一篇文章。
不要使用select xx from aa bb where aa.f=bb.f这样的语法，hive不支持这种写法。
如果需要查看hive的执行计划，你可以在语句前加上explain，比如：
explain Select a.stuNo,b.teacherName from student a jointeacher b on a.classNo = b.classNo;
外连接（outer join）
和传统SQL类似，Hive提供了left outer join，right outer join，full out join。
半连接（semi join）
Hive不提供in子查询。此时你可以用leftsemi join实现同样的功能。
执行以下语句：
Select&* from teacher left semi join student onstudent.classNo = teacher.classNo;
输出结果如下：
C01& Zhang
可以看出，C04 Dong没有出现在查询结果中，因为C04在表student中不存在。
右表（student）中的字段只能出现在on子句中，不能出现在其他地方，比如不能出现在select子句中。
Map连接（map join）
当一个表非常小，足以直接装载到内存中去时，可以使用map连接以提高效率，比如：
Select&/*+mapjoin(teacher) */&a.stuNo,b.teacherNamefrom student a join teacher b on a.classNo = b.classNo;
以上红色标记部分采用了C的注释风格。
当连接时用到不等值判断时，也比较适合Map连接。具体原因需要深入了解Hive和MapReduce的工作原理。
子查询（sub query）
运行以下语句将返回所有班级平均分的最高记录。
Select max(avgScore) as maScore
(Select classNo,avg(score) as avgScore from student group byclassNo)
输出结果：
以上语句中红色部分为一个子查询，且别名为a。返回的子查询结果和一个表类似，可以被继续查询。
视图（view）
和传统数据库中的视图类似，Hive的视图只是一个定义，视图数据并不会存储到文件系统中。同样，视图是只读的。
运行以下两个命令：
Create view avg_score as
Select classNo,avg(score) as avgScore from student groupby classNo;
Select max(avgScore) as maScore
可以看到输出结果和上例中的结果是一样的。
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：785650次
积分：10743
积分：10743
排名：第634名
原创：310篇
转载：238篇
评论：114条
(3)(2)(5)(6)(5)(3)(3)(4)(7)(14)(22)(33)(22)(12)(15)(19)(20)(8)(16)(5)(3)(10)(9)(5)(9)(17)(15)(6)(10)(6)(15)(5)(14)(8)(30)(30)(6)(9)(3)(3)(5)(19)(3)(7)(10)(8)(4)(2)(5)(3)(6)(3)(3)(9)(25)hive中怎么写查询语句会让reduce的数量多_百度知道
hive中怎么写查询语句会让reduce的数量多
提问者采纳
开启动态分区：hive.exec.dynamic.partition=true默认值：false描述：是否允许动态分区hive.exec.dynamic.partition.mode=nonstrict默认值：strict描述：strict是避免全分区字段是动态的，必须有至少一个分区字段是指定有值的。读取表的时候可以不指定分区。设置如下参数配置动态分区的使用环境：hive.exec.max.dynamic.partitions.pernode=100默认值：100描述：each mapper or reducer可以创建的最大动态分区数hive.exec.max.dynamic.partitions=1000默认值：1000描述：一个DML操作可以创建的最大动态分区数hive.exec.max.created.files=100000默认值：100000描述：一个DML操作可以创建的文件数设置如下参数取消一些限制(HIVE 0.7后没有此限制)：hive.merge.mapfiles=false默认值：true描述：是否合并Map的输出文件，也就是把小文件合并成一个maphive.merge.mapredfiles=false默认值：false描述：是否合并Reduce的输出文件，也就是在Map输出阶段做一次reduce操作，再输出set hive.input.format=org.apache.hadoop.hive.bineHiveInputF这个参数表示执行前进行小文件合并，前面三个参数确定合并文件块的大小，大于文件块大小128m的，按照128m来分隔，小于128m,大于100m的，按照100m来分隔，把那些小于100m的（包括小文件和分隔大文件剩下的），进行合并,最终生成了74个块。自0.7版本后Hive开始支持任务执行选择本地模式(local mode)，如此一来，对数据量比较小的操作，就可以在本地执行，这样要比提交任务到集群执行效率要快很多。 配置如下参数，可以开启Hive的本地模式：hive& set hive.exec.mode.local.auto=(默认为false)
来自团队：
其他类似问题
为您推荐：
等待您来回答
下载知道APP
随时随地咨询
出门在外也不愁通过Hive执行任务，异常——Hive：Connection refused；Hadoop：too many open files - 推酷
通过Hive执行任务，异常——Hive：Connection refused；Hadoop：too many open files
问题背景：
工作中需要用到Hiveserver提交任务到hadoop进行离线计算，在正常测试运行整个离线计算任务
后，在后面提交任务的运行过程中遇到该异常。
问题表现：
从监控模块放回的异常与Hive中日志异常一样，均为如下所示：
15:14:12 [ERROR] [SummaryReport] [orderNumStatics/订单量] File '/home/hadoop/hive-0.7.1-cdh3u3/lib/py/hive_service/ThriftHive.py', line 87, in recv_execute
raise result.ex
HiveServerException:HiveServerException(errorCode=12, message='Query returned non-zero code: 12, cause: FAILED: Hive Internal Error: java.lang.RuntimeException(java.net.ConnectException: Call to nn/10.28.168.128:41000 failed on connection exception: java.net.ConnectException: Connection refused)', SQLState='42000')
hadoop集群中datanode的日志文件报异常：
DataXceiverServer: IOException due to:java.io.IOException: Too many open files
在后面的测试中进一步得到如下情况：
在遇到该异常后，立即直接通过Hive（非Thrift）提交查询语句，返回同样的错误；等待几分钟后，重新提交Hive语句，可执行成功。继续提交，当达到一定量之后，又返回之前的错误。重新启动hiveserver或hadoop，均可以很好地解决只能执行少量任务的问题。
问题原因：
目前我们应用的hadoop版本hadoop-0.20.2-cdh3u3，其存在一个Bug，编号：&
Bug 描述如下：
When I load data into tables of hive via hiver cli or hive server, there are always some ESTABLISHED or CLOSE_WAIT status socket connections. And these tcp connections won't be released unless you quit hive or restart hiveserver.
意思是： 当用户通过hive 与 hive server执行hadoop任务时， 系统中会存在一些状体为&ESTABLISHED 与CLOSE_WAIT 的socket连接，而这些tcp连接只有在退出hive，或重启hiveserver服务时才会释放。
通过这个Bug的描述，发现这正是我们当前遇到的问题。
解决方法：
1. 修复上述中的Bug， path 补丁文件&1010-HDFS-1836.-Thousand-of-CLOSE_WAIT-socket.patch， 重新生成hadoop-core-0.20.2-cdh3u3.jar，然后替换掉之前的jar包；
2.&修改hadoop集群节点的/etc/security/limits.conf文件，在文件末尾加入下内容：
* soft nofile 65536
* hard nofile 65536
此操作的含义是修改Linux系统允许打开的最大文件数，其中系统默认的文件打开数为1024，这里修改成65536，根据实际情况设置成相应的值即可。
3. 修改hadoop配置文件&hdfs-site.xml，修改dfs.datanode.max.xcievers属性的值，可根据实际情况设置大一点
&property&
&name&dfs.datanode.max.xcievers&/name&
&value&4096&/value&
&/property&
解决效果：
在与hadoop小组同时的沟通过程中得知，解决方法中的步骤一已经实施，但在我们的实际情况中依然会遇到本文中描述的问题。分析原因可能有如下几种：
1. hadoop-0.20.2-cdh3u3的这个bug并未真正修复；
2. hadoop-0.20.2-cdh3u3已修复该bug，而处理这些未及时关闭的链接，采取的方案可能是等待操作关闭，即需要某个设定的时间再关闭。
在实施解决方案中的步骤2、3之后，经过多次测试，没有再遇到本文中提到的问题。继续测试发现未关闭的链接数保持在一定值，呈现上下浮动，并没有一直往上增长，故大胆猜测，执行步骤一未能解决问题的原因很可能是上述的第2点。具体是哪种原因，以及上述原因2中可能的等待时间是多长，本人还在学习当中。
已发表评论数()
&&登&&&录&&
已收藏到推刊！
请填写推刊名
描述不能大于100个字符!
权限设置： 公开
仅自己可见Hive 的官方文档中对查询语言有了很详细的描述，请参考：http://wiki.apache.org/hadoop/Hive/LanguageManual ，本文的内容大部分翻译自该页面，期间加入了一些在使用过程中需要注意到的事项。
Create Table
CREATE [EXTERNAL] TABLE [IF NOT EXISTS] table_name
& [(col_name data_type [COMMENT col_comment], ...)]
& [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]
& [ROW FORMAT row_format]
& [STORED AS file_format]
& [LOCATION hdfs_path]
CREATE TABLE 创建一个指定名字的表。如果相同名字的表已经存在，则抛出异常；用户可以用 IF NOT EXIST 选项来忽略这个异常。
EXTERNAL 关键字可以让用户创建一个外部表，在建表的同时指定一个指向实际数据的路径（LOCATION），Hive 创建内部表时，会将数据移动到数据仓库指向的路径；若创建外部表，仅记录数据所在的路径，不对数据的位置做任何改变。在删除表的时候，内部表的元数据和数据会被一起删除，而外部表只删除元数据，不删除数据。
LIKE 允许用户复制现有的表结构，但是不复制数据。
用户在建表的时候可以自定义 SerDe 或者使用自带的 SerDe。如果没有指定 ROW FORMAT 或者 ROW FORMAT DELIMITED，将会使用自带的 SerDe。在建表的时候，用户还需要为表指定列，用户在指定表的列的同时也会指定自定义的 SerDe，Hive 通过 SerDe 确定表的具体的列的数据。
如果文件数据是纯文本，可以使用 STORED AS TEXTFILE。如果数据需要压缩，使用 STORED AS SEQUENCE 。
有分区的表可以在创建的时候使用 PARTITIONED BY 语句。一个表可以拥有一个或者多个分区，每一个分区单独存在一个目录下。而且，表和分区都可以对某个列进行 CLUSTERED BY 操作，将若干个列放入一个桶（bucket）中。也可以利用SORT BY 对数据进行排序。这样可以为特定应用提高性能。
表名和列名不区分大小写，SerDe 和属性名区分大小写。表和列的注释是字符串。
Drop Table
删除一个内部表的同时会同时删除表的元数据和数据。删除一个外部表，只删除元数据而保留数据。
Alter Table
Alter table 语句允许用户改变现有表的结构。用户可以增加列/分区，改变serde，增加表和 serde 熟悉，表本身重命名。
Add Partitions
ALTER TABLE table_name ADD
& partition_spec [ LOCATION 'location1' ]
& partition_spec [ LOCATION 'location2' ] ...
partition_spec:
& : PARTITION (partition_col = partition_col_value,
& &partition_col = partiton_col_value, ...)
用户可以用 ALTER TABLE ADD PARTITION 来向一个表中增加分区。当分区名是字符串时加引号。
& ALTER TABLE page_view ADD
& & PARTITION (dt='', country='us')
& & & location '/path/to/us/part080808'
& & PARTITION (dt='', country='us')
& & & location '/path/to/us/part080809';
DROP PARTITION
ALTER TABLE table_name DROP
& & partition_spec, partition_spec,...
用户可以用 ALTER TABLE DROP PARTITION 来删除分区。分区的元数据和数据将被一并删除。
ALTER TABLE page_view
& & DROP PARTITION (dt='', country='us');
RENAME TABLE
ALTER TABLE table_name RENAME TO new_table_name
这个命令可以让用户为表更名。数据所在的位置和分区名并不改变。换而言之，老的表名并未“释放”，对老表的更改会改变新表的数据。
Change Column Name/Type/Position/Comment
ALTER TABLE table_name CHANGE [COLUMN]
& col_old_name col_new_name column_type
& & [COMMENT col_comment]
& & [FIRST|AFTER column_name]
这个命令可以允许用户修改一个列的名称、数据类型、注释或者位置。
CREATE TABLE test_change (a int, b int, c int);
ALTER TABLE test_change CHANGE a a1 INT; 将 a 列的名字改为 a1.
ALTER TABLE test_change CHANGE a a1 STRING AFTER 将 a 列的名字改为 a1，a 列的数据类型改为 string，并将它放置在列 b 之后。新的表结构为： b int, a1 string, c int.
ALTER TABLE test_change CHANGE b b1 INT FIRST; 会将 b 列的名字修改为 b1, 并将它放在第一列。新表的结构为： b1 int, a string, c int.
注意：对列的改变只会修改 Hive 的元数据，而不会改变实际数据。用户应该确定保证元数据定义和实际数据结构的一致性。
Add/Replace Columns
ALTER TABLE table_name ADD|REPLACE
& COLUMNS (col_name data_type [COMMENT col_comment], ...)
ADD COLUMNS 允许用户在当前列的末尾增加新的列，但是在分区列之前。
REPLACE COLUMNS 删除以后的列，加入新的列。只有在使用 native 的 SerDE（DynamicSerDe or MetadataTypeColumnsetSerDe）的时候才可以这么做。
Alter Table Properties
ALTER TABLE table_name SET TBLPROPERTIES table_properties
table_properties:
& : (property_name = property_value, property_name = property_value, ... )
用户可以用这个命令向表中增加 metadata，目前 last_modified_user，last_modified_time 属性都是由 Hive 自动管理的。用户可以向列表中增加自己的属性。可以使用 DESCRIBE EXTENDED TABLE 来获得这些信息。
Add Serde Properties
ALTER TABLE table_name
& & SET SERDE serde_class_name
& & [WITH SERDEPROPERTIES serde_properties]
ALTER TABLE table_name
& & SET SERDEPROPERTIES serde_properties
serde_properties:
& : (property_name = property_value,
& & property_name = property_value, ... )
这个命令允许用户向 SerDe 对象增加用户定义的元数据。Hive 为了序列化和反序列化数据，将会初始化 SerDe 属性，并将属性传给表的 SerDe。如此，用户可以为自定义的 SerDe 存储属性。
Alter Table File Format and Organization
ALTER TABLE table_name SET FILEFORMAT file_format
ALTER TABLE table_name CLUSTERED BY (col_name, col_name, ...)
& [SORTED BY (col_name, ...)] INTO num_buckets BUCKETS
这个命令修改了表的物理存储属性。
Loading files into table
当数据被加载至表中时，不会对数据进行任何转换。Load 操作只是将数据复制/移动至 Hive 表对应的位置。
LOAD DATA [LOCAL] INPATH 'filepath' [OVERWRITE]
& & INTO TABLE tablename
& & [PARTITION (partcol1=val1, partcol2=val2 ...)]
Load 操作只是单纯的复制/移动操作，将数据文件移动到 Hive 表对应的位置。
filepath 可以是：
相对路径，例如：project/data1
绝对路径，例如： /user/hive/project/data1
包含模式的完整 URI，例如：hdfs://namenode:9000/user/hive/project/data1
加载的目标可以是一个表或者分区。如果表包含分区，必须指定每一个分区的分区名。
filepath 可以引用一个文件（这种情况下，Hive 会将文件移动到表所对应的目录中）或者是一个目录（在这种情况下，Hive 会将目录中的所有文件移动至表所对应的目录中）。
如果指定了 LOCAL，那么：
load 命令会去查找本地文件系统中的 filepath。如果发现是相对路径，则路径会被解释为相对于当前用户的当前路径。用户也可以为本地文件指定一个完整的 URI，比如：file:///user/hive/project/data1.
load 命令会将 filepath 中的文件复制到目标文件系统中。目标文件系统由表的位置属性决定。被复制的数据文件移动到表的数据对应的位置。
如果没有指定 LOCAL 关键字，如果 filepath 指向的是一个完整的 URI，hive 会直接使用这个 URI。 否则：
如果没有指定 schema 或者 authority，Hive 会使用在 hadoop 配置文件中定义的 schema 和 authority，fs.default.name 指定了 Namenode 的 URI。
如果路径不是绝对的，Hive 相对于 /user/ 进行解释。
Hive 会将 filepath 中指定的文件内容移动到 table （或者 partition）所指定的路径中。
如果使用了 OVERWRITE 关键字，则目标表（或者分区）中的内容（如果有）会被删除，然后再将 filepath 指向的文件/目录中的内容添加到表/分区中。
如果目标表（分区）已经有一个文件，并且文件名和 filepath 中的文件名冲突，那么现有的文件会被新文件所替代。
SELECT [ALL | DISTINCT] select_expr, select_expr, ...
& FROM table_reference
& [WHERE where_condition]
& [GROUP BY col_list]
& & CLUSTER BY col_list
& & | [DISTRIBUTE BY col_list]
& & [SORT BY col_list]
[LIMIT number]
一个SELECT语句可以是一个union查询或一个子查询的一部分。
table_reference是查询的输入，可以是一个普通表、一个视图、一个join或一个子查询
简单查询。例如，下面这一语句从t1表中查询所有列的信息。
SELECT * FROM t1
WHERE Clause
where condition 是一个布尔表达式。例如，下面的查询语句只返回销售记录大于 10，且归属地属于美国的销售代表。Hive 不支持在WHERE 子句中的 IN，EXIST 或子查询。
SELECT * FROM sales WHERE amount & 10 AND region = &US&
ALL and DISTINCT Clauses
使用ALL和DISTINCT选项区分对重复记录的处理。默认是ALL，表示查询所有记录。DISTINCT表示去掉重复的记录。
hive& SELECT col1, col2 FROM t1
hive& SELECT DISTINCT col1, col2 FROM t1
hive& SELECT DISTINCT col1 FROM t1
基于Partition的查询
一般 SELECT 查询会扫描整个表（除非是为了抽样查询）。但是如果一个表使用 PARTITIONED BY 子句建表，查询就可以利用分区剪枝（input pruning）的特性，只扫描一个表中它关心的那一部分。Hive 当前的实现是，只有分区断言出现在离 FROM 子句最近的那个WHERE 子句中，才会启用分区剪枝。例如，如果 page_views 表使用 date 列分区，以下语句只会读取分区为‘’的数据。
&SELECT page_views.*
& & FROM page_views
& & WHERE page_views.date &= ''
& & & AND page_views.date &= '';
HAVING Clause
Hive 现在不支持 HAVING 子句。可以将 HAVING 子句转化为一个字查询，例如：
SELECT col1 FROM t1 GROUP BY col1 HAVING SUM(col2) & 10
可以用以下查询来表达：
SELECT col1 FROM (SELECT col1, SUM(col2) AS col2sum
& FROM t1 GROUP BY col1) t2
& WHERE t2.col2sum & 10
LIMIT Clause
Limit 可以限制查询的记录数。查询的结果是随机选择的。下面的查询语句从 t1 表中随机查询5条记录：
SELECT * FROM t1 LIMIT 5
Top k 查询。下面的查询语句查询销售记录最大的 5 个销售代表。
SET mapred.reduce.tasks = 1
& SELECT * FROM sales SORT BY amount DESC LIMIT 5
REGEX Column Specification
SELECT 语句可以使用正则表达式做列选择，下面的语句查询除了 ds 和 hr 之外的所有列：
SELECT `(ds|hr)?+.+` FROM sales
join_table:
& & table_reference JOIN table_factor [join_condition]
& | table_reference {LEFT|RIGHT|FULL} [OUTER]
& & JOIN table_reference join_condition
& | table_reference LEFT SEMI JOIN
& & & table_reference join_condition
table_reference:
& & table_factor
& | join_table
table_factor:
& & tbl_name [alias]
& | table_subquery alias
& | ( table_references )
join_condition:
& & ON equality_expression ( AND equality_expression )*
equality_expression:
& & expression = expression
Hive 只支持等值连接（equality joins）、外连接（outer joins）和（left semi joins???）。Hive 不支持所有非等值的连接，因为非等值连接非常难转化到 map/reduce 任务。另外，Hive 支持多于 2 个表的连接。
写 join 查询时，需要注意几个关键点：
1. 只支持等值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)
是错误的。
2. 可以 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。“FROM a LEFT OUTER JOIN b”这句一定要写在同一行——意思是 a 表在 b 表的左边，所以 a 表中的所有记录都被保留了；“a RIGHT OUTER JOIN b”会保留所有 b 表的记录。OUTER JOIN 语义应该是遵循标准 SQL spec的。
Join 发生在 WHERE 子句之前。如果你想限制 join 的输出，应该在 WHERE 子句中写过滤条件——或是在 join 子句中写。这里面一个容易混淆的问题是表分区的情况：
& SELECT a.val, b.val FROM a
& LEFT OUTER JOIN b ON (a.key=b.key)
& WHERE a.ds='' AND b.ds=''
会 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='' AND
& & & a.ds='')
这一查询的结果是预先在 join 阶段过滤过的，所以不会存在上述问题。这一逻辑也可以应用于 RIGHT 和 FULL 类型的 join 中。
Join 是不能交换位置的。无论是 LEFT 还是 RIGHT join，都是左连接的。
& SELECT a.val1, a.val2, b.val, c.val
& 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。
LEFT SEMI JOIN 是 IN/EXISTS 子查询的一种更高效的实现。Hive 当前没有实现 IN/EXISTS 子查询，所以你可以用 LEFT SEMI JOIN 重写你的子查询语句。LEFT SEMI JOIN 的限制是， JOIN 子句中右边的表只能在 ON 子句中设置过滤条件，在 WHERE 子句、SELECT 子句或其他地方过滤都不行。
& SELECT a.key, a.value
& WHERE a.key in
& &(SELECT b.key
& & FROM B);
可以被重写为：
& &SELECT a.key, a.val
& &FROM a LEFT SEMI JOIN b on (a.key = b.key)
本站文章除注明转载外，均为本站原创；欢迎任何形式的转载，但请务必注明出处
转载请注明：文章转载自：聚资库 []
本文标题：Hive创建表 查询HQL语句
本文地址：
Hive命令行
执行HQL查询
hive -e &select * from tb&
查询结果输出为文本
hive -e &select * from tb& & tb.txt
执行HQL语句文件后，不会进入交互模式
hive -f hive-script.sql
执行HQL语句文件后，会进入交互模式
hive -i hive-script.sql
设置Hive的日志级别
hive -hiveconf
Hive安装及配置，准备工作：
1).安装JDK1.6
2).安装Hadoop-1.0.4
3).安装MySQL5.x
上面都安装好后，接下来就可以安装Hive了，目前最新版本为hive0.10.0，从hive0.8.0开始，就支持hadoop1.x了，这里安装的是hive0.8.1，具体步骤如下：
1.下载hive-0.8.1.tar.gz
下载地址：wget /apache/hive/hive-0.8.
Explain命令在解决数据库性能上是第一推荐使用命令，大部分的性能问题可以通过此命令来简单的解决，Explain可以用来查看 SQL 语句的执行效 果，可以帮助选择更好的索引和优化查询语句，写出更好的优化语句。 Explain语法：explain select … from … [where ...] 例如：explain select * 输出：+----+-------------+-------+-------+-----------------
ibatis控制台输出SQL语句：调试代码的时候，会希望在控制台打印正在执行的SQL语句，这样就知道哪些SQL语句有问题。只要在log4j.properties文件里加上下面的配置，就可以在控制台打印SQL语句了。
.ibatis=DEBUG .mon.jdbc.SimpleDataSource=DEBUG .mon.jdbc.Script
东东有个神奇的体温表，它不仅可以测到体温还可以测到心情。东东最怕的数学考试来临时，体温表知道他很恐慌不想去考试，就把温度升上去很多，东东就因为可以请病假而不用去考试了；东东发烧的时候，却非常想出去春游，体温表得知了他期待的心情，就把体温的数字降低到正常，东东就高兴的去玩了，但结果回家后病情就加重了。
时间一长，东东就发现了是体温表有问题，生气的对他说：“你干嘛要自作聪明啊？你就是一个体温表而已！你就明明白白告诉我事实真相就好了啊！！！你凭什么变来变去的！”这时候体温表委屈的
1. 复制表结构及其数据： create table table_name_new as select * from table_name_old & 2. 只复制表结构： create table table_name_new as select * from table_name_old where 1=2; 或者： create table table_name_new like table_name_old & 3. 只复制表数据： 如果两个表结构
Windows下启动服务：
OracleOraDb10g_home1TNSlistener：(启动命令：lsnrctl start)
OracleService[服务名]：(启动命令：oradim -starup -sid orcl) Linux下启动服务：
lsnrctl start
sqlplus / as sysdba
startup 登录：
sqlplus / as sysdba(SYS用户登录)
sqlplus yaya/123456(一般用户登录)
Lucene 原理与代码分析系列文章已经基本告一段落，可能问题篇还会有新的更新。 & 完整版pdf可由以附件下载。 & 目录如下： 第一篇：原理篇
第一章：全文检索的基本原理
二、索引里面究竟存些什么
三、如何创建索引
第一步：一些要索引的原文档(Document)。
第二步：将原文档传给分次组件(Tokenizer)。
第三步：将得到的词元(Token)传给语言处理组件(Linguistic Processor)。
第四步：将得
SQLite数据库的基本使用及对返回结果进行简单的封装，可直接返回Object或List类型，省去自动转换成Object或List的麻烦。
主要代码如下：
package com.juziku.demo. import java.lang.reflect.F import java.util.ArrayL import java.util.L import android.content.ContentV import
一、Connection对象
&&&&& Connection对象也称为数据库连接对象，Connection对象的功能是负责对数据源的连接。所有Connection对象的基类都是DbConnection类。& &&&&& Connection对象的2个重要熟悉 ：& &&&&&（1）ConnectionSt
世上最遥远的距离，不是生与死的距离，不是天各一方，而是我就站在你面前，你却不知道我爱你。 那些曾经以为念念不忘的事情就在我们念念不忘的过程里，被我们遗忘了．我们放下尊严, 放下个性, 放下固执,都只是因为放不下一个人。&& 喜欢一个人，是不会有痛苦的。爱一个人，也许有绵长的痛苦，但他给我的快乐，也是世上最大的快乐。&& 爱人是很卑微的， 很卑微的， 如果对方不爱你的话。&& 带给你快乐的那个人， 就是也能带给你痛苦的
1、I asked God for a bike, but I know God doesn't work that way. So I stole a bike and asked for forgiveness. 开始我直接求上帝赐辆自行车。后来我琢磨上帝办事儿不是这个路数。于是老子偷了一辆然后求上帝宽恕。
2、I want to die peacefully in my sleep, like my grandfather.. Not screaming and y
遇到性能问题时，一般有这么几种可能：
1、索引没有建好；
2、sql写法过于复杂；
3、配置错误；
4、机器实在负荷不了；
1、索引没有建好
如果看到mysql消耗的cpu很大，可以用mysql的client工具来检查。
在linux下执行
/usr/local/mysql/bin/mysql -hlocalhost -uroot -p&
输入密码，如果没有密码，则不用-p参数就可以进到客户端界面中。
看看当前的运行情况
能原谅女人谎言的才是真正的男人-海贼王 山治
鲁鲁修，你知道雪为什么是白色的吗？因为它忘记了自己曾经的颜色。
——C.C《叛逆的鲁鲁修》 女王的这段话回味好久
人们之所以怀有一丝希望，是因为他们看不见死亡。
——朽木露琪亚《死神》
我在人生道路上迷失了方向。
——旗木卡卡西《火影》
花开了，然后凋零。星星是璀璨的，可那光芒也会消失。
这个地球、太阳、银河系甚至连这个宇宙也会有死亡的时候。
人的一生和这些东西相比，简直
Sporting house 妓院（不是体育室）
Dead president 美钞（不是死了的总统）
Lover 情人（不是爱人）
Busboy 餐馆勤杂工（不是公汽售票员）
Busybody 爱管闲事的人（不是大忙人）
Dry goods 纺织品 谷物（不是干货）
Heart man 换心人（不是有心人）
Mad doctor精神病科医生（不是发疯的医生）
Eleventh hour最后时刻（
mysql中删除表记录delete from和truncate table的用法区别:
MySQL中有两种删除表中记录的方法，一种是delete from语句，另一种是truncate table语句。
delete from语句可以使用where对要删除的记录进行选择。而使用truncate table将删除表中的所有记录。因此，delete语句更灵活。
如果要清空表中的所有记录，可以使用下面的两种方法：
delete from tablename trun
自身所缺维生素病状&& & & &&&& & & &&& 需要补充的维生素种类 -----------------------------------------------------------------------------------------
眼干涩 & & & & & &nbs
MySQL开启远程连接，主要是修改mysql数据库里的user表，来开启远程连接的。
登入mysql后，更改mysql 数据库里的user表里的host项，从localhost改称%
如下所示： mysql& /*使用mysql数据库*/ mysql&update user set host = ‘%’ where user = ‘root’; mysql& /*使修改的生效，要执行此语句*/ 这样，
Java,本身是一门非常优秀的面向对象语言,严格的面向对象语法,跨平台,学习简单…使用相当广泛,它的优秀是无可厚非的,但它也有一些争议,比如class文件的半编译方式会降底系统性能,还有单继承的限制有时候让人不爽(可以理解,但这点我支持java的方式),还有最重要的就是Java导致很多开发人员只会编代码,而对很多计算机科学应该知道的知识不了解.因为Java太上层了.但如果一个java出生的程序员又对计算机科学有广泛的爱好,那java可以带来很多面向对象编程,架构等等的思路指导
一、选择题 (1) 下面叙述正确的是(C) A. 算法的执行效率与数据的存储结构无关 B. 算法的空间复杂度是指算法程序中指令（或语句）的条数 C. 算法的有穷性是指算法必须能在执行有限个步骤之后终止 D. 以上三种描述都不对 (2) 以下数据结构中不属于线性数据结构的是(C) A. 队列 B. 线性表 C. 二叉树 D. 栈 (3) 在一棵二叉树上第5层的结点数最多是(B) 注：由公式2k-1得 A. 8 B. 16 C. 32 D. 15 (4) 下面描述中，符合结构化程
& juziku.net, all rights reserved