华为云用户手册

手动压缩操作步骤 如果不希望系统自动确定何时压缩表，则可以设置表属性“NO_AUTO_Compaction”关闭自动压缩。关闭自动压缩后仍然可以使用ALTER Table /Partition Compact语句进行手动压缩。 该操作仅适用于MRS 8.2.0及之后版本。 参考使用Hive客户端登录Hive客户端，执行以下命令在创建表时关闭自动压缩： CREATE TABLE table_name ( id int, name string)CLUSTERED BY (id) INTO 2 BUCKETS STORED AS ORCTBLPROPERTIES ("transactional"="true", "NO_AUTO_COMPACTION"="true"); 也可在表创建成功后执行以下命令关闭自动压缩： ALTER TABLE table_name set TBLPROPERTIES ("NO_AUTO_COMPACTION"="true"); 执行以下命令设置表的压缩类型，其中，“compaction_type”表示压缩类型，包括“minor”和“major”： ALTER TABLE table_name COMPACT 'compaction_type';

事务特性介绍 事务（transaction）是一组单元化操作，这些操作要么都执行，要么都不执行，是一个不可分割的工作单位。事务的四个基本要素通常被称为ACID特性，分别为： 原子性（Atomicity）：一个事务是一个不可再分割的工作单位，事务中的所有操作要么都发生，要么都不发生。 一致性（Consistency）：事务开始之前和事务结束以后，数据库的完整性约束没有被破坏。 隔离性（Isolation）：多个事务并发访问，事务之间是隔离的，一个事务不影响其它事务运行效果。事务之间的影响有：脏读、不可重复读、幻读、丢失更新。 持久性（Durability）：在事务完成以后，该事务锁对数据库所做的更改将永久保存在数据库中。 事务执行特点： 一条语句可以写入多个分区或多个表。如果操作失败，则用户看不到部分写入或插入。即使频繁更改数据，仍然能够快速执行操作。 Hive能够自动压缩ACID事务文件，而不会影响并发查询。当查询许多小分区文件时，自动压缩可提高查询性能和元数据占用量。 读取语义包括快照隔离。当读取操作开始时，Hive在逻辑上处于锁定仓库的状态。读操作不受操作期间发生的任何更改的影响。

Grouping 语法简介： 当Group by语句带with rollup/cube选项时，Grouping才有意义。 CUBE生成的结果集显示了所选列中值的所有组合的聚合。 ROLLUP生成的结果集显示了所选列中值的某一层次结构的聚合。 Grouping：当用CUBE或ROLLUP运算符添加行时，附加的列输出值为1；当所添加的行不是由CUBE或ROLLUP产生时，附加列值为0。 例如，Hive中有一张表“table_test”，表结构如下所示： +----------------+-------------------+--+| table_test.id | table_test.value |+----------------+-------------------+--+| 1 | 10 || 1 | 15 || 2 | 20 || 2 | 5 || 2 | 13 |+----------------+-------------------+--+ 执行如下语句： select id,grouping(id),sum(value) from table_test group by id with rollup; 得到如下结果： +-------+-----------------+------+--+| id | groupingresult | sum |+-------+-----------------+------+--+| 1 | 0 | 25 || NULL | 1 | 63 || 2 | 0 | 38 |+-------+-----------------+------+--+

EXCEPT、INTERSECT 语法简介 EXCEPT返回两个结果集的差（即从左查询中返回右查询没有找到的所有非重复值）。 INTERSECT返回两个结果集的交集（即两个查询都返回的所有非重复值）。 例如，Hive中有两张表“test_table1”、“test_table2”。 “test_table1”表结构如下所示： +-----------------+--+| test_table1.id |+-----------------+--+| 1 || 2 || 3 || 4 |+-----------------+--+ “test_table2”表结构如下所示： +-----------------+--+| test_table2.id |+-----------------+--+| 2 || 3 || 4 || 5 |+-----------------+--+ 执行如下的EXCEPT语句： select id from test_table1 except select id from test_table2; 显示如下结果： +--------------+--+| _alias_0.id |+--------------+--+| 1 |+--------------+--+ 执行INTERSECT语句： select id from test_table1 intersect select id from test_table2; 显示如下结果： +--------------+--+| _alias_0.id |+--------------+--+| 2 || 3 || 4 |+--------------+--+

HDFS文件系统目录简介 HDFS文件系统中目录结构如下表所示。 表1 HDFS文件系统目录结构 路径 类型 简略功能 是否可以删除 删除的后果 /tmp/spark2x/sparkhive-scratch 固定目录 存放Spark2x JDBCServer中metastore session临时文件 否 任务运行失败 /tmp/sparkhive-scratch 固定目录 存放Spark2x cli方式运行metastore session临时文件 否 任务运行失败 /tmp/logs/ 固定目录 存放container日志文件 是 container日志不可查看 /tmp/carbon/ 固定目录 数据导入过程中，如果存在异常CarbonData数据，则将异常数据放在此目录下 是 错误数据丢失 /tmp/Loader-${作业名}_${MR作业id} 临时目录 存放Loader Hbase bulkload作业的region信息，作业完成后自动删除 否 Loader Hbase Bulkload作业失败 /tmp/hadoop-omm/yarn/system/rmstore 固定目录 ResourceManager运行状态信息 是 ResourceManager重启后状态信息丢失 /tmp/archived 固定目录 MR任务日志在HDFS上的归档路径 是 MR任务日志丢失 /tmp/hadoop-yarn/staging 固定目录 保存AM运行作业运行日志、作业概要信息和作业配置属性 否 任务运行异常 /tmp/hadoop-yarn/staging/history/done_intermediate 固定目录 所有任务运行完成后，临时存放/tmp/hadoop-yarn/staging目录下文件 否 MR任务日志丢失 /tmp/hadoop-yarn/staging/history/done 固定目录 周期性扫描线程定期将done_intermediate的日志文件转移到done目录 否 MR任务日志丢失 /tmp/mr-history 固定目录 存储预加载历史记录文件的路径 否 MR历史任务日志数据丢失 /tmp/hive-scratch 固定目录 Hive运行时生成的临时数据，如会话信息等 否 当前执行的任务会失败 /user/{user}/.sparkStaging 固定目录 存储SparkJDBCServer应用临时文件 否 executor启动失败 /user/spark2x/jars 固定目录 存放Spark2x executor运行依赖包 否 executor启动失败 /user/loader 固定目录 存放loader的作业脏数据以及HBase作业数据的临时存储目录 否 HBase作业失败或者脏数据丢失 /user/loader/etl_dirty_data_dir /user/loader/etl_hbase_putlist_tmp /user/loader/etl_hbase_tmp /user/oozie 固定目录 存放oozie运行时需要的依赖库，需用户手动上传 否 oozie调度失败 /user/mapred/hadoop-mapreduce-xxx.tar.gz 固定文件 MR分布式缓存功能使用的各jar包 否 MR分布式缓存功能无法使用 /user/hive 固定目录 Hive相关数据存储的默认路径，包含依赖的spark lib包和用户默认表数据存储位置等 否 用户数据丢失 /user/omm-bulkload 临时目录 HBase批量导入工具临时目录 否 HBase批量导入任务失败 /user/hbase 临时目录 HBase批量导入工具临时目录 否 HBase批量导入任务失败 /spark2xJobHistory2x 固定目录 Spark2x eventlog数据存储目录 否 HistoryServer服务不可用，任务运行失败 /flume 固定目录 Flume采集到HDFS文件系统中的数据存储目录 否 Flume工作异常 /mr-history/tmp 固定目录 MapReduce作业产生的日志存放位置 是 日志信息丢失 /mr-history/done 固定目录 MR JobHistory Server管理的日志的存放位置 是 日志信息丢失 /tenant 添加租户时创建 配置租户在HDFS中的存储目录，系统默认将自动在“/tenant”目录中以租户名称创建文件夹。例如租户“ta1”，默认HDFS存储目录为“tenant/ta1”。第一次创建租户时，系统自动在HDFS根目录创建“/tenant”目录。支持自定义存储路径。 否 租户不可用 /apps{1~5}/ 固定目录 WebHCat使用到Hive的包的路径 否 执行WebHCat任务会失败 /hbase 固定目录 HBase数据存储目录 否 HBase用户数据丢失 /hbaseFileStream 固定目录 HFS文件存储目录 否 HFS文件丢失，且无法恢复 父主题： 使用HDFS

配置描述 参数入口： 请参考修改集群服务配置参数，进入HDFS的“全部配置”页面，在搜索框中输入参数名称。 表1 参数说明 参数 描述 默认值 fs.permissions.umask-mode 当客户端在HDFS上创建文件和目录时使用此umask值（用户掩码）。类似于linux上的文件权限掩码。 可以使用八进制数字也可以使用符号，例如：“022” (八进制，等同于以符号表示的u=rwx,g=r-x,o=r-x)，或者“u=rwx,g=rwx,o=”(符号法，等同于八进制的“007”)。 说明： 8进制的掩码，和实际权限设置值正好相反，建议使用符号表示法，描述更清晰。 022

操作场景 通常一个集群上部署了多个服务，且大部分服务的存储都依赖于HDFS文件系统。当集群运行时，不同组件（例如Spark、Yarn）或客户端可能会向同一个HDFS目录不断写入文件。但HDFS系统支持的单目录文件数目是有上限的，因此用户需要提前做好规划，防止单个目录下的文件数目超过阈值，导致任务出错。 HDFS提供了“dfs.namenode.fs-limits.max-directory-items”参数设置单个目录下可以存储的文件数目。

操作步骤 请参考修改集群服务配置参数，进入HDFS的“全部配置”页面。 搜索配置项“dfs.namenode.fs-limits.max-directory-items”。 表1 参数说明 参数名称 描述 默认值 dfs.namenode.fs-limits.max-directory-items 定义目录中包含的最大条目数。 取值范围：1～6400000 1048576 设置单个HDFS目录下最大可容纳的文件数目。保存修改的配置。保存完成后请重新启动配置过期的服务或实例以使配置生效。 用户尽量将数据做好存储规划，可以按时间、业务类型等分类，不要单个目录下直属的文件过多，建议使用默认值，单个目录下约100万条。

补充说明 Flume可靠性保障措施。 Source与Channel、Channel与Sink之间支持事务机制。 Sink Processor支持配置failover、load_balance机制。 例如load_balance示例如下： server.sinkgroups=g1server.sinkgroups.g1.sinks=k1 k2server.sinkgroups.g1.processor.type=load_balanceserver.sinkgroups.g1.processor.backoff=trueserver.sinkgroups.g1.processor.selector=random Flume多客户端聚合级联时的注意事项。 级联时需要走Avro或者Thrift协议进行级联。 聚合端存在多个节点时，连接配置尽量配置均衡，不要聚合到单节点上。 Flume客户端可以包含多个独立的数据流，即在一个配置文件properties.properties中配置多个Source、Channel、Sink。这些组件可以链接以形成多个流。 例如在一个配置中配置两个数据流，示例如下： server.sources = source1 source2server.sinks = sink1 sink2server.channels = channel1 channel2#dataflow1 server.sources.source1.channels = channel1server.sinks.sink1.channel = channel1#dataflow2server.sources.source2.channels = channel2server.sinks.sink2.channel = channel2

CASE 标准的SQL CASE表达式有两种模式。 “简单模式”从左向右查找表达式的每个value，直到找出相等的expression： CASE expression WHEN value THEN result [ WHEN ... ] [ ELSE result ] END 返回匹配value的result。如果没有匹配到任何值，则返回ELSE子句的result；如果没有ELSE子句，则返回空。示例： select a,case a when 1 then 'one' when 2 then 'two' else 'many' end from (values (1),(2),(3),(4)) as t(a); a | _col1 ---|------- 1 | one 2 | two 3 | many 4 | many (4 rows) “查找模式”从左向右判断每个condition的布尔值，直到判断为真，返回匹配result： CASE WHEN condition THEN result [ WHEN ... ] [ ELSE result ] END 如果判断条件都不成立，则返回ELSE子句的result；如果没有ELSE子句，则返回空。示例： select a,b,casewhen a=1 then 'one'when b=2 then 'tow'else 'many' end from (values (1,2),(3,4),(1,3),(4,2)) as t(a,b); a | b | _col2 ---|---|------- 1 | 2 | one 3 | 4 | many 1 | 3 | one 4 | 2 | tow (4 rows)

IF IF函数是语言结构，它与下面的CASE表达式功能相同： CASE WHEN condition THEN true_value [ ELSE false_value ] END if(condition, true_value) 如果condition为真，返回true_value；否则返回NULL，true_value不进行计算。 select if(a=1,8) from (values (1),(1),(2)) as t(a); -- 8 8 NULLselect if(a=1,'value') from (values (1),(1),(2)) as t(a); -- value value NULL if(condition, true_value, false_value) 如果condition为真，返回true_value；否则计算并返回false_value 。 select if(a=1,'on','off') from (values (1),(1),(2)) as t(a); _col0 ------- on on off (3 rows)

TRY 评估一个表达式，如果出错，则返回Null。类似于编程语言中的try catch。try函数一般结合COALESCE使用，COALESCE可以将异常的空值转为0或者空，以下情况会被try捕获： 分母为0 错误的cast操作或者函数入参 数字超过了定义长度 不推荐使用，应该明确以上异常，做数据预处理 示例： 假设有以下表，字段origin_zip中包含了一些无效数据： -- 创建表create table shipping (origin_state varchar,origin_zip varchar,packages int ,total_cost int);-- 插入数据insert into shipping values ('California','94131',25,100),('California','P332a',5,72),('California','94025',0,155),('New Jersey','08544',225,490);-- 查询数据SELECT * FROM shipping; origin_state | origin_zip | packages | total_cost --------------+------------+----------+------------ California | 94131 | 25 | 100 California | P332a | 5 | 72 California | 94025 | 0 | 155 New Jersey | 08544 | 225 | 490 (4 rows) 不使用Try查询失败： SELECT CAST(origin_zip AS BIGINT) FROM shipping;Query failed: Cannot cast 'P332a' to BIGINT 使用Try返回NULL： SELECT TRY(CAST(origin_zip AS BIGINT)) FROM shipping; origin_zip ------------ 94131 NULL 94025 08544 (4 rows) 不使用try查询失败： SELECT total_cost/packages AS per_package FROM shipping;Query failed: Division by zero 使用TRY和COALESCE返回默认值： SELECT COALESCE(TRY(total_cost/packages),0) AS per_package FROM shipping; per_package ------------- 4 14 0 19 (4 rows)

Bitwise函数 bit_count(x, bits) → bigint 计算2的补码表示法中x中设置的位数（视为有符号位的整数）。 SELECT bit_count(9, 64); -- 2SELECT bit_count(9, 8); -- 2SELECT bit_count(-7, 64); -- 62SELECT bit_count(-7, 8); -- 6 bitwise_and(x, y) → bigint 以二进制补码形式返回x和y按位与的结果。 select bitwise_and(8, 7); -- 0 bitwise_not(x) → bigint 以二进制补码形式返回x按位非的结果。 select bitwise_not(8);-- -9 bitwise_or(x, y) → bigint 以二进制补码形式返回x和y按位或的结果。 select bitwise_or(8,7);-- 15 bitwise_xor(x, y) → bigint 以二进制补码形式返回x和y按位异或的结果。 参考聚合函数中的bitwise_and_agg() 和 bitwise_or_agg() 父主题： SQL函数和操作符

NULLIF nullif(value1, value2) 如果value1与value2相等，返回NULL；否则返回value1 。 select nullif(a,b) from (values (1,1),(1,2)) as t(a,b); -- _col0 ------- NULL 1 (2 rows) ZEROIFNULL(value) 如果value为null，返回0，否则返回原值。目前支持数值类型还有varchar类型。 select zeroifnull(a),zeroifnull(b),zeroifnull(c) from (values (null,13.11,bigint '157'),(88,null,bigint '188'),(55,14.11,null)) as t(a,b,c); _col0 | _col1 | _col2 -------|-------|------- 0 | 13.11 | 157 88 | 0.00 | 188 55 | 14.11 | 0 (3 rows) NVL(value1,value2) 如果value1为NULL，返回value2，否则，返回value1。 select nvl(NULL,3); -- 3select nvl(2,3); --2 ISNULL(value) 如果value1为NULL，返回true，否则返回false。 Create table nulltest(col1 int,col2 int);insert into nulltest values(null,3);select isnull(col1),isnull(col2) from nulltest; _col0 | _col1 -------|------- true | false (1 row) ISNOTNULL(value) 如果value1为NULL，返回false，否则返回true。 select isnotnull(col1),isnotnull(col2) from nulltest; _col0 | _col1 -------|------- false | true (1 row)

描述 调用指定的存储过程。 存储过程由各个连接（connnectors）提供，实现数据操作或者管理任务。例如，系统连接器（System Connector）就定义了存储过程可以取消一个正在运行的查询。有些数据源，例如PostgreSQL，其系统有定义自己的存储过程，这与连接器定义的存储过程不同，是无法被CALL调用的。 检查并更新metastroe中分区数组，它支持3种模式： ADD：将文件系统中存在但metastore里没有的分区系统同步到metastroe中。 DROP：drop元数据表中存在但文件系统中不存在的分区。 FULL：同时进行ADD和DROP操作。

示例 下面这个例子，你可以看到每个阶段（Stage）的CPU时间消耗，每个计划节点相应的代价。 这个代价是基于现实时间（wall time），而非CPU 的相关时间。 对每一个计划节点，都可以看到额外的统计信息，例如每个节点实例的输入平均值，哈希碰撞（hash collisions）的平均次数。这些统计信息对于分析一条SQL语句中的数据异常情况（skewness数据倾斜，abnormal hash collisions）非常有用。 EXPLAIN ANALYZE SELECT count(*),sum(totalprice) FROM new_orders GROUP BY orderstatus; Query Plan ------------------------------------------------------------------------------------------------------------------------------- Fragment 1 [HASH] CPU: 29.19ms, Scheduled: 134.78ms, Input: 2 rows (77B); per task: avg.: 1.00 std.dev.: 1.00, Output: 2 rows (36B) Output layout: [count, sum] Output partitioning: SINGLE [] Stage Execution Strategy: UNGROUPED_EXECUTION Project[] │ Layout: [count:bigint, sum:double] │ Estimates: {rows: ? (?), cpu: ?, memory: ?, network: ?} │ CPU: 4.00ms (2.34%), Scheduled: 10.00ms (33.33%), Output: 2 rows (36B) │ Input avg.: 0.06 rows, Input std.dev.: 387.30% └─ Aggregate(FINAL)[orderstatus][$hashvalue] │ Layout: [orderstatus:varchar, $hashvalue:bigint, count:bigint, sum:double] │ Estimates: {rows: ? (?), cpu: ?, memory: ?, network: ?} │ CPU: 6.00ms (3.51%), Scheduled: 17.00ms (56.67%), Output: 2 rows (77B) │ Input avg.: 0.06 rows, Input std.dev.: 387.30% │ count := count("count_9") │ sum := sum("sum_10") └─ LocalExchange[HASH][$hashvalue] ("orderstatus") │ Layout: [orderstatus:varchar, sum_10:double, count_9:bigint, $hashvalue:bigint] │ Estimates: {rows: ? (?), cpu: ?, memory: ?, network: ?} │ CPU: 2.00ms (1.17%), Scheduled: 3.00ms (10.00%), Output: 2 rows (77B) │ Input avg.: 0.06 rows, Input std.dev.: 556.78% └─ RemoteSource[2] Layout: [orderstatus:varchar, sum_10:double, count_9:bigint, $hashvalue_11:bigint] CPU: 1.00ms (0.58%), Scheduled: 3.00ms (10.00%), Output: 2 rows (77B) Input avg.: 0.06 rows, Input std.dev.: 556.78% Fragment 2 [SOURCE] CPU: 17.35ms, Scheduled: 80.04ms, Input: 4 rows (81B); per task: avg.: 4.00 std.dev.: 0.00, Output: 2 rows (77B) Output layout: [orderstatus, sum_10, count_9, $hashvalue_12] Output partitioning: HASH [orderstatus][$hashvalue_12] Stage Execution Strategy: UNGROUPED_EXECUTION Aggregate(PARTIAL)[orderstatus][$hashvalue_12] │ Layout: [orderstatus:varchar, $hashvalue_12:bigint, sum_10:double, count_9:bigint] │ CPU: 1.00ms (0.58%), Scheduled: 6.00ms (20.00%), Output: 2 rows (77B) │ Input avg.: 4.00 rows, Input std.dev.: 0.00% │ sum_10 := sum("totalprice") │ count_9 := count(*) └─ ScanProject[table = hive:default:new_orders, grouped = false] Layout: [orderstatus:varchar, totalprice:double, $hashvalue_12:bigint] Estimates: {rows: 4 (292B), cpu: 256, memory: 0B, network: 0B}/{rows: 4 (292B), cpu: 548, memory: 0B, network: 0B} CPU: 16.00ms (9.36%), Scheduled: 132.00ms (440.00%), Output: 4 rows (117B) Input avg.: 4.00 rows, Input std.dev.: 0.00% $hashvalue_12 := "combine_hash"(bigint '0', COALESCE("$operator$hash_code"("orderstatus"), 0)) orderstatus := orderstatus:string:1:REGULAR totalprice := totalprice:double:2:REGULAR Input: 4 rows (81B), Filtered: 0.00% (1 row)

示例 LOGICAL： CREATE TABLE testTable (regionkey int, name varchar);EXPLAIN SELECT regionkey, count(*) FROM testTable GROUP BY 1; Query Plan ------------------------------------------------------------------------------------------------------------------------------------- Output[regionkey, _col1] │ Layout: [regionkey:integer, count:bigint] │ Estimates: {rows: ? (?), cpu: ?, memory: ?, network: ?} │ _col1 := count └─ RemoteExchange[GATHER] │ Layout: [regionkey:integer, count:bigint] │ Estimates: {rows: ? (?), cpu: ?, memory: ?, network: ?} └─ Project[] │ Layout: [regionkey:integer, count:bigint] │ Estimates: {rows: ? (?), cpu: ?, memory: ?, network: ?} └─ Aggregate(FINAL)[regionkey][$hashvalue] │ Layout: [regionkey:integer, $hashvalue:bigint, count:bigint] │ Estimates: {rows: ? (?), cpu: ?, memory: ?, network: ?} │ count := count("count_8") └─ LocalExchange[HASH][$hashvalue] ("regionkey") │ Layout: [regionkey:integer, count_8:bigint, $hashvalue:bigint] │ Estimates: {rows: ? (?), cpu: ?, memory: ?, network: ?} └─ RemoteExchange[REPARTITION][$hashvalue_9] │ Layout: [regionkey:integer, count_8:bigint, $hashvalue_9:bigint] │ Estimates: {rows: ? (?), cpu: ?, memory: ?, network: ?} └─ Aggregate(PARTIAL)[regionkey][$hashvalue_10] │ Layout: [regionkey:integer, $hashvalue_10:bigint, count_8:bigint] │ count_8 := count(*) └─ ScanProject[table = hive:default:testtable] Layout: [regionkey:integer, $hashvalue_10:bigint] Estimates: {rows: 0 (0B), cpu: 0, memory: 0B, network: 0B}/{rows: 0 (0B), cpu: 0, memory: 0B, network: 0B} $hashvalue_10 := "combine_hash"(bigint '0', COALESCE("$operator$hash_code"("regionkey"), 0)) regionkey := regionkey:int:0:REGULAR DISTRIBUTED： EXPLAIN (type DISTRIBUTED) SELECT regionkey, count(*) FROM testTable GROUP BY 1; Query Plan ----------------------------------------------------------------------------------------------------------------------- Fragment 0 [SINGLE] Output layout: [regionkey, count] Output partitioning: SINGLE [] Stage Execution Strategy: UNGROUPED_EXECUTION Output[regionkey, _col1] │ Layout: [regionkey:integer, count:bigint] │ Estimates: {rows: ? (?), cpu: ?, memory: ?, network: ?} │ _col1 := count └─ RemoteSource[1] Layout: [regionkey:integer, count:bigint] Fragment 1 [HASH] Output layout: [regionkey, count] Output partitioning: SINGLE [] Stage Execution Strategy: UNGROUPED_EXECUTION Project[] │ Layout: [regionkey:integer, count:bigint] │ Estimates: {rows: ? (?), cpu: ?, memory: ?, network: ?} └─ Aggregate(FINAL)[regionkey][$hashvalue] │ Layout: [regionkey:integer, $hashvalue:bigint, count:bigint] │ Estimates: {rows: ? (?), cpu: ?, memory: ?, network: ?} │ count := count("count_8") └─ LocalExchange[HASH][$hashvalue] ("regionkey") │ Layout: [regionkey:integer, count_8:bigint, $hashvalue:bigint] │ Estimates: {rows: ? (?), cpu: ?, memory: ?, network: ?} └─ RemoteSource[2] Layout: [regionkey:integer, count_8:bigint, $hashvalue_9:bigint] Fragment 2 [SOURCE] Output layout: [regionkey, count_8, $hashvalue_10] Output partitioning: HASH [regionkey][$hashvalue_10] Stage Execution Strategy: UNGROUPED_EXECUTION Aggregate(PARTIAL)[regionkey][$hashvalue_10] │ Layout: [regionkey:integer, $hashvalue_10:bigint, count_8:bigint] │ count_8 := count(*) └─ ScanProject[table = hive:default:testtable, grouped = false] Layout: [regionkey:integer, $hashvalue_10:bigint] Estimates: {rows: 0 (0B), cpu: 0, memory: 0B, network: 0B}/{rows: 0 (0B), cpu: 0, memory: 0B, network: 0B} $hashvalue_10 := "combine_hash"(bigint '0', COALESCE("$operator$hash_code"("regionkey"), 0)) regionkey := regionkey:int:0:REGULAR VALIDATE： EXPLAIN (TYPE VALIDATE) SELECT id, count(*) FROM testTable GROUP BY 1; Valid------- true IO： EXPLAIN (TYPE IO, FORMAT JSON) SELECT regionkey , count(*) FROM testTable GROUP BY 1; Query Plan --------------------------------- { "inputTableColumnInfos" : [ { "table" : { "catalog" : "hive", "schemaTable" : { "schema" : "default", "table" : "testtable" } }, "columnConstraints" : [ ] } ] } COST： EXPLAIN (TYPE COST, FORMAT JSON) SELECT regionkey , count(*) FROM testTable GROUP BY 1; Query Plan ----------------------------- "Aggregated": { "CPU Time": 0.0 "MaxMemory": 0.0 "outputRows": 0.0 "outputSize(bytes)": 0.0 } (1 row)

描述 显示一条语句的逻辑的或者分布式的执行计划，也可以用于校验一条SQL语句，或者是分析IO。 参数TYPE DISTRIBUTED用于显示分片后的计划（fragmented plan）。每一个fragment都会被一个或者多个节点执行。Fragments separation表示数据在两个节点之间进行交换。Fragment type表示一个fragment如何被执行以及数据在不同fragment之间怎样分布。 SINGLE Fragment会在单个节点上执行。 HASH Fragment会在固定数量的节点上执行，输入数据通过哈希函数进行分布。 ROUND_ROBIN Fragment会在固定数量的节点上执行，片段在固定数量的节点上执行，输入数据以轮循方式进行分布。 BROADCAST Fragment会在固定数量的节点上执行，输入数据被广播到所有的节点。 SOURCE Fragment在访问输入分段的节点上执行。

示例 --PREPARE my_select1 FROM SELECT * FROM fruit; DESCRIBE OUTPUT my_select1;--PREPARE my_select2 FROM SELECT count(*) as my_count, 1+2 FROM fruit; DESCRIBE OUTPUT my_select2;--PREPARE my_create FROM CREATE TABLE foo AS SELECT * FROM fruit; DESCRIBE OUTPUT my_create;

示例 收集表fruit的统计信息： ANALYZE fruit; 统计catalog hive、schema default下的表存储： ANALYZE hive.default.orders; 从hive分区表中统计分区'2020-07-17' , '2020-07-18'信息： ANALYZE hive.web.page_views WITH (partitions = ARRAY[ARRAY['2020-07-17','US'], ARRAY['2020-07-18','US']]);

SEMI JOIN、ANTI JOIN 当一张表在另一张表找到匹配的记录之后，半连接（semi-join）返回第一张表中的记录。与条件连接相反，即使在右节点中找到几条匹配的记录，左节点的表也只会返回一条记录。另外，右节点的表一条记录也不会返回。半连接通常使用IN或EXISTS作为连接条件。 而anti-join则与semi-join相反，即当在第二张表没有发现匹配记录时，才会返回第一张表里的记录；当使用not exists/not in的时候会用到。 其他支持的条件包括如下内容： where子句中的多个条件 别名关系 下标表达式 解引用表达式 强制转换表达式 特定函数调用 目前，只在如下情况下支持多个semi/anti join表达式：第一个表中的列在其直接后续的join表达式中被查询，且不与其它join表达式有关系。 示例如下：

BERNOULLI 每一行都将基于指定的采样率选择到采样表中。当使用Bernoulli方法对表进行采样时，将扫描表的所有物理块并跳过某些行（基于采样百分比和运行时计算的随机值之间的比较）。结果中包含一行的概率与任何其他行无关。这不会减少从磁盘读取采样表所需的时间。如果进一步处理采样输出，则可能会影响总查询时间。 SELECT * FROM users TABLESAMPLE BERNOULLI (50);

示例 CREATE SCHEMA web; DESCRIBE SCHEMA web; Describe Schema ------------------------------------------------------------------------- web hdfs://hacluster/user/hive/warehouse/web.db admintest USER (1 row)

Qualifying Column Names 当JOIN的两个relation有相同的列名时，列引用必须使用relation别名（如果relation有别名）或relation名称进行限定： SELECT nation.name, region.name FROM nation CROSS JOIN region;SELECT n.name, r.name FROM nation AS n CROSS JOIN region AS r;SELECT n.name, r.name FROM nation n CROSS JOIN region r;

SYSTEM 此采样方法将表划分为数据的逻辑段，并按此粒度对表进行采样。此采样方法要么从特定数据段中选择所有行，要么跳过它（基于采样百分比与运行时计算的随机值之间的比较）。系统采样中行的选择依赖于使用的connector。例如，如果使用Hive数据源，这将取决于数据在HDFS上的布局。这种采样方法不能保证独立的抽样概率。 SELECT * FROM users TABLESAMPLE SYSTEM (75);

示例 describe formatted show_table1 a; Describe Formatted Column ------------------------------ col_name a data_type integer min max num_nulls distinct_count 0 avg_col_len max_col_len num_trues num_falses comment (1 row)

INTERSECT query INTERSECT [DISTINCT] query INTERSECT仅返回第一个和第二个查询的结果相交的行。以下是最简单的INTERSECT子句之一的示例。它选择值13和42，并将此结果集与选择值13的第二个查询合并。由于42仅在第一个查询的结果集中，因此不包含在最终结果中。 SELECT * FROM (VALUES 13,42) INTERSECT SELECT 13; _col0 ------- 13 (1 row)

EXCEPT query EXCEPT [DISTINCT] query EXCEPT返回在第一个查询结果而不在第二个查询结果中的行。 SELECT * FROM (VALUES 13, 42) EXCEPT SELECT 13; _col0------- 42(1 row) Having子句目前不支持使用列的别名，例如： select count(userid) as num ,dept as aaa from salary group by dept having aaa='d1'; 报错如下： Query 20210630_085136_00024_wc8n9@default@HetuEngine failed: line 1:75: Column 'aaa' cannot be resolved

FETCH FIRST FETCH { FIRST | NEXT } [ count ] { ROW | ROWS } { ONLY | WITH TIES FETCH FIRST支持FIRST或NEXT关键字以及ROW或ROWS关键字。这些关键字等效，不影响query执行。 如果FETCH FIRST未指定数量，默认为1： SELECT orderdate FROM orders FETCH FIRST ROW ONLY; orderdate -------------- 2020-11-11 SELECT * FROM new_orders FETCH FIRST 2 ROW ONLY; orderkey | orderstatus | totalprice | orderdate --------------|-------------|------------|-------------- 202011181113 | online | 9527.0 | 2020-11-11 202011181114 | online | 666.0 | 2020-11-11 (2 rows) 如果使用了OFFSET，则LIMIT或FETCH FIRST会在OFFSET之后应用于结果集： SELECT * FROM (VALUES 5, 2, 4, 1, 3) t(x) ORDER BY x OFFSET 2 FETCH FIRST ROW ONLY; x --- 3 (1 row) 对于FETCH FIRST子句，参数ONLY或WITH TIES控制结果集中包含哪些行。 如果指定了ONLY参数，则结果集将限制为包含参数数量的前若干行。 如果指定了WITH TIES参数，则要求必须带ORDER BY子句。其结果集中包含符合条件的前若干行基本结果集以及额外的行。这些额外的返回行与基本结果集中最后一行的ORDER BY的参数一样： CREATE TABLE nation (name varchar, regionkey integer);insert into nation values ('ETHIOPIA',0),('MOROCCO',0),('ETHIOPIA',2),('KENYA',2),('ALGERIA',0),('MOZAMBIQUE',0);--返回regionkey与第一条相同的所有记录。SELECT name, regionkey FROM nation ORDER BY regionkey FETCH FIRST ROW WITH TIES; name | regionkey ------------|----------- ALGERIA | 0 ETHIOPIA | 0 MOZAMBIQUE | 0 MOROCCO | 0 (4 rows)

使用多个列 SELECT numbers, animals, n, aFROM (VALUES(ARRAY[2, 5], ARRAY['dog', 'cat', 'bird']),(ARRAY[7, 8, 9], ARRAY['cow', 'pig'])) AS x (numbers, animals)CROSS JOIN UNNEST(numbers, animals) AS t (n, a);