分布式排序 分布式排序允许对超过query.max-memory-per-node的数据排序。分布式排序通过协调节点的etc/config.properties中设置的distributed_sort会话属性或distributed-sort配置属性集启用。分布式排序默认启用。 当启用分布式排序时，排序算子在集群中的多个节点上并行执行。每个openLooKeng工作节点的已部分排序数据随后被流式传输到单个工作节点以进行最终合并。该技术允许利用多个openLooKeng工作节点的内存进行排序。分布式排序的主要目的是允许对通常不适合单节点内存的数据集进行排序。可以预期性能将得到提升，但是这种提升不会随着节点数的增多而线性增长，因为数据需要由单个节点合并。
动态目录 本节介绍openLooKeng的动态目录特性。通常openLooKeng管理员通过将目录概要文件（例如hive.properties）放置在连接节点目录（etc/catalog）下来将数据源添加到引擎。每当需要添加、更新或删除目录时，都需要重启所有协调节点和工作节点。 为了动态修改目录，openLooKeng引入了动态目录的特性。动态目录的原理是，将目录相关的配置文件在一个共享文件系统上管理，然后所有协调节点和工作节点从共享文件系统上同步到本地，并加载。开启此特性需要： 首先，在etc/config.properties中配置： catalog.dynamic-enabled=true 其次，在hdfs-config-default.properties中配置用于存储动态目录信息的文件系统。你可以通过etc/node.properties中的catalog.share.filesystem.profile属性修改这个文件名，默认为hdfs-config-default，你可以查看文件系统文档以获取更多信息。 在etc/filesystem/路径下添加hdfs-config-default.properties文件， 如果这个路径不存在，请创建。 fs.client.type=hdfs hdfs.config.resources=/opt/openlookeng/config/core-site.xml, /opt/openlookeng/config/hdfs-site.xml hdfs.authentication.type=NONE fs.hdfs.impl.disable.cache=true 如果HDFS开启Kerberos认证，那么 fs.client.type=hdfs hdfs.config.resources=/opt/openlookeng/config/core-site.xml, /opt/openlookeng/config/hdfs-site.xml hdfs.authentication.type=KERBEROS hdfs.krb5.conf.path=/opt/openlookeng/config/krb5.conf hdfs.krb5.keytab.path=/opt/openlookeng/config/user.keytab hdfs.krb5.principal=openlookeng@HADOOP.COM # replace openlookeng@HADOOP.COM to your principal fs.hdfs.impl.disable.cache=true 最后，在etc/node.properties配置用户文件系统中的存储动态目录信息的路径，用于指定共享文件系统上与本地存放目录相关的配置文件的路径；同时因为需要从共享文件系统上的相同路径同步配置文件，所以所有协调节点和工作节点的共享文件系统上的路径必须一致，本地的存放路径不做要求。 catalog.config-dir=/opt/openlookeng/catalog catalog.share.config-dir=/opt/openkeng/catalog/share 使用 目录操作是通过openLooKeng协调节点上的RESTful API来完成的。HTTP请求具有如下形态（以Hive连接节点为例），POST/PUT请求体形式为multipart/form-data： curl --location --request POST 'http://your_coordinator_ip:9101/v1/catalog' \ --header 'X-Presto-User: admin' \ --form 'catalogInformation="{ \"catalogName\" : \"hive\", \"connectorName\" : \"hive-hadoop2\", \"properties\" : { \"hive.hdfs.impersonation.enabled\" : \"false\", \"hive.hdfs.authentication.type\" : \"KERBEROS\", \"hive.collect-column-statistics-on-write\" : \"true\", \"hive.
动态过滤 本节介绍openLooKeng动态过滤特性。动态过滤适用于高选择性join场景，即大多数的probe侧的表在读取之后由于不匹配join条件而被过滤掉。 openLooKeng在查询运行时，依靠join条件以及build侧读出的数据，生成动态过滤条件，并作为额外的过滤条件应用到probe侧表的table scan阶段，从而减少参与join操作的probe表的数据量，有效地减少IO读取与网络传输。 适用场景 openLooKeng动态过滤主要应用于高选择性的join场景（包含针对分区表的分区裁剪以及非分区表的行过滤）。openLooKeng动态过滤当前适用于inner join，semi join 以及right join场景，适用于Hive connector，DC connector以及Memory connector。 使用 openLooKeng动态过滤特性依赖于分布式缓存组件，请参考State Store章节配置。 在/etc/config.properties需要配置如下参数 enable-dynamic-filtering=true dynamic-filtering-data-type=BLOOM_FILTER dynamic-filtering-max-per-driver-size=100MB dynamic-filtering-max-per-driver-row-count=10000 dynamic-filtering-bloom-filter-fpp=0.1 上述属性说明如下： enable-dynamic-filtering：是否开启动态过滤特性。 dynamic-filtering-wait-time：等待动态过滤条件生成的最长等待时间，默认值是1s。 dynamic-filtering-data-type：设置动态过滤类型，可选包含BLOOM_FILTER以及HASHSET，默认类型为BLOOM_FILTER。 dynamic-filtering-max-size: 每个dynamic filter的大小上限，如果预估大小超过设定值，代价优化器不会生成对应的dynamic filter，默认值是1000000。 dynamic-filtering-max-per-driver-size：每个driver可以收集的数据大小上限，默认值是1MB。 dynamic-filtering-max-per-driver-row-count：每个driver可以收集的数据条目上限，默认值是10000。 dynamic-filtering-bloom-filter-fpp：动态过滤使用的bloomfilter的FPP值，默认是0.1。 如果应用于Hive connector，需要对catalog/hive.properties如下修改： hive.dynamic-filter-partition-filtering=true hive.dynamic-filtering-row-filtering-threshold=5000 上述属性说明如下： hive.dynamic-filter-partition-filtering：使用动态过滤条件根据分区值进行预先过滤，默认值是false。 hive.dynamic-filtering-row-filtering-threshold：如果动态过滤条件大小低于阈值，则应用行过滤，默认值是2000。 执行计划 下面的例子展示了SQL语句如何应用动态过滤条件，在执行计划中标记为dynamicFilter。 可以使用explain命令查看动态过滤是否应用，也可以在webUI中的liveplan查看当前执行是否应用动态过滤。 create table table1 (id integer, year varchar); create table table2 (id integer, total integer); insert into table1 values (1, '2019'), (2, '2020'), (3, '2021'); insert into table2 values (1, 100), (2, 200); Inner join:
扩展物理执行计划 本节介绍openLooKeng如何添加扩展物理执行计划。通过物理执行计划的扩展，openLooKeng可以使用其他算子加速库来加速SQL语句的执行。 配置 首先，需要从以下链接获取相关jar包和c++库： boostkit-omniop-openlookeng-1.6.1-1.0.0-aarch64.jar: Link libboostkit-omniop-xx-1.0.0-aarch.so: Link 然后，在配置文件config.properties增加如下配置： extension_execution_planner_enabled=true extension_execution_planner_jar_path=file:///xxPath/boostkit-omniop-openlookeng-1.6.1-1.0.0-aarch64.jar extension_execution_planner_class_path=nova.hetu.olk.OmniLocalExecutionPlanner 上述属性说明如下： extension_execution_planner_enabled：是否开启扩展物理执行计划特性。 extension_execution_planner_jar_path：指定扩展jar包的文件路径。 extension_execution_planner_class_path：指定扩展jar包中执行计划生成类的包路径。 使用 当运行openLooKeng时，可在WebUI或Cli中通过如下命令控制扩展物理执行计划的开启: set session extension_execution_planner_enabled=true/false
函数命名空间管理器 注意 目前提供外部数据源函数(外部函数)的注册管理及下推的体验功能，此特性还在开发中，一些接口和配置项在后续的版本中可能会有改动。 函数命名空间管理器介绍 函数命名空间管理器是用来管理外部函数的，各个connector注册的外部函数(当前只支持标量函数)会在此空间管理。 一个函数命名空间表示为 catalog.schema(例如：mysqlfun.default)，可以理解为函数定义存储的模式，不过此模式只能用于函数，不支持表或视图之类。 每个函数，不管是built in函数的还是外部注册的外部函数，都属于一个格式为catalog.schema的函数命名空间。 外部类型函数的全引用名为函数命名空间加上函数名(例如：mysqlfun.default.func)。 所有built in函数的使用方式为直接使用函数名，如：select count(*) from ...。外部函数需要使用全引用名，如：select mysqlfun.default.format(...) from ...。 每个函数命名空间管理器与一个catalog关联，并且管理此catalog下的所有函数。 建议不使用实际connector_catalog名称作为函数命名空间管理器catalog。 加载函数命名空间管理器 当要加载一个名称为mysqlfun的函数命名空间管理器来管理名称为mysqlfun的catalog下的所有函数， 我们可以添加一个名称为 etc/function-namespace/mysqlfun.properties的文件, 同时，请在文件中写入如下配置内容: function-namespace-manager.name=memory supported-function-languages=JDBC 当前仅支持类型为memory函数命名空间管理器，memory类型的函数命名空间管理器在系统重启后，需要重新加载外部函数信息。 配置项supported-function-languages表明当前函数命名空间管理器实例支持的外部函数种类，你可以自己定义注册类型，此项参数需要用户定义的外部函数注册信息一致。 当前我们仅支持JDBC。 加载多个函数命名空间管理器 当需要管理属于不同catalog的外部函数时，我们需要在etc/function-namespace目录下配置多个文件名不同的文件来加载多个函数命名空间管理器分别管理属于不同catalog的外部函数。 外部函数注册到函数命名空间管理器 当前openLooKeng系统支持通过Jdbc Connector注册外部函数。具体请参考 外部函数注册 外部函数下推到数据源执行 openLooKeng系统支持外部函数通过Jdbc Connector下推到数据源执行。具体请参考 外部函数注册。 注意 外部函数仅支持下推到数据源执行。 如果一个外部函数不能下推到数据源，则当前的包含外部函数调用的查询将会失败。
水平伸缩 用例 自动/手动伸缩 openLooKeng集群可动态增减节点，支持伸缩场景。虽然资源提供者有责任确定何时进行伸缩以及在进行缩容时要删除哪些节点，但openLooKeng会确保这些更改正常生效。特别是，在进行缩容期间，删除节点不会影响该节点上的工作负载。 对于自动伸缩场景，资源提供者可能希望基于以下因素做出决策： 系统指标，如CPU、内存、I/O，或 节点工作负载状态（参见下面的状态API） 例如，openLooKeng可以部署在Kubernetes环境中，使用HorizontalPodAutoscaler自动伸缩集群大小。你可以在hetu-samples模块的Kubernetes下找到一些示例部署数据。 节点维护 如果一个节点需要暂时从openLooKeng集群中分离出来，例如执行一些维护任务，可以先隔离该节点，然后再重新加入集群。 节点状态API 通过调用节点的状态API，可以获取该节点的工作负载信息。包括CPU和内存的分配和使用信息。返回值结构请参考io.prestosql.server.NodeStatus类。 例如，使用curl并假设节点地址为1.2.3.4:8080。 $ curl http://1.2.3.4:8080/v1/status | jq { "nodeId": "...", ... "memoryInfo": { "availableProcessors": ..., "totalNodeMemory": "...", ... }, "processors": ..., "processCpuLoad": ..., "systemCpuLoad": ..., "heapUsed": ..., "heapAvailable": ..., "nonHeapUsed": ... } 节点状态管理接口 可通过节点状态管理接口实现伸缩和隔离。 关闭节点 如果集群不再需要一个节点（例如：作为缩容操作的一部分），可以关闭该节点。 这样的过程是优雅的，因为 集群不会向该节点分配新的工作负载，并且 节点在关闭主进程之前会尝试完成所有现有的工作负载。 关闭过程不可逆。可以通过REST API将SHUTTING_DOWN状态放到节点的info/state端点来启动该过程。例如： $ curl -X PUT -H "Content-Type: application/json" http://1.2.3.4:8080/v1/info/state \ -d '"SHUTTING_DOWN"' 隔离节点 隔离是将节点暂时从集群中移除。
元数据存储 本节介绍openLooKeng元数据存储。元数据存储用于存储元数据信息, 当前元数据存储支持将元数据保存在RDBMS或HDFS中。 配置元数据存储 首先在etc目录下创建配置文件hetu-metastore.properties。 使用RDBMS存储 在配置文件hetu-metastore.properties增加如下配置： hetu.metastore.type=jdbc hetu.metastore.db.url=jdbc:mysql://.... hetu.metastore.db.user=root hetu.metastore.db.password=123456 hetu.metastore.cache.type=local 上述属性说明如下： hetu.metastore.type：元数据存储类型，使用RDBMS存储时配置为jdbc。 hetu.metastore.db.url：连接RDBMS的URL。 hetu.metastore.db.user :连接RDBMS的用户名。 hetu.metastore.db.password :连接RDBMS的密码。 hetu.metastore.cache.type :选择缓存模型,其中local为本地缓存,global为分布式缓存。 使用HDFS存储 在配置文件hetu-metastore.properties增加如下配置： hetu.metastore.type=hetufilesystem hetu.metastore.hetufilesystem.profile-name=hdfs-config-metastore hetu.metastore.hetufilesystem.path=/etc/openlookeng/metastore 上述属性说明如下： hetu.metastore.type：元数据存储类型，使用HDFS存储时配置为hetufilesystem。 hetu.metastore.hetufilesystem.profile-name：使用HDFS存储配置文件的名称。 hetu.metastore.hetufilesystem.path：配置文件的路径。 可以从文件系统中获取更多的文件系统相关的信息 元数据存储缓存 openLooKeng可以配置开启元数据缓存，开启后访问元数据时会将其缓存到内存中，再次访问时可以提高元数据访问效率。 在配置文件hetu-metastore.properties增加如下配置： hetu.metastore.cache.size=10000 hetu.metastore.cache.ttl=4h 上述属性说明如下： hetu.metastore.cache.size：元数据缓存大小，默认10000。 hetu.metastore.cache.ttl：缓存元数据的过期时间，默认值0 (元数据缓存关闭)。
JDBC数据源多分片管理 功能介绍 该功能适用于JDBC数据源，旨在通过把待读取的数据表划分为多个分片，并由集群的多个worker节点同时发起读取数据分片，以达到加快数据读取速度的效果。 属性配置 多分片管理的配置以连接器为单位，开启该功能的数据表需要在所属的连接器的配置文件（例如名为mysql的连接器对应的配置文件为etc/catalog/mysql.properties）添加以下属性： 属性列表： 配置文件配置项说明: jdbc.table-split-enabled=true jdbc.table-split-stepCalc-refresh-interval=10s jdbc.table-split-stepCalc-threads=2 jdbc.table-split-fields=[{"catalogName":"test_catalog", "schemaName":null, "tableName":"test_table", "splitField":"id","dataReadOnly":"true", "calcStepEnable":"false", "splitCount":"5","fieldMinValue":"1","fieldMaxValue":"10000"},{"catalogName":"test_catalog1", "schemaName":"test_schema1", "tableName":"test_tabl1", "splitField":"id", "dataReadOnly":"false", "calcStepEnable":"true", "splitCount":"5", "fieldMinValue":"","fieldMaxValue":""}] 上述属性说明如下： jdbc.table-split-enabled：是否开启多分片读取数据功能，默认为false。 jdbc.table-split-stepCalc-refresh-interval：动态更新分片的取值范围的周期，默认值为5分钟。 jdbc.table-split-stepCalc-threads：动态更新分片的取值范围的线程数，默认值为4。 jdbc.table-split-fields：各个数据表的分片配置信息，请参考"分片配置信息填写说明”。 分片配置信息填写说明 每个数据表的配置信息由多个子属性构成，按JSON格式的来填写，说明如下： 子属性名称 描述 填写建议 catalogName 该数据表在数据源里所属的catalog的名字，对应标准jdbc的DatabaseMetaData.getTables接口返回的"TABLE_CAT"字段的内容 按实际值填写，空值请填null schemaName 该数据表在数据源里所属的schema的名字，对应标准jdbc的DatabaseMetaData.getTables接口返回的"TABLE_SCHEM"字段的内容 按实际值填写，空值请填null tableName 该数据表在数据源里的名字，对应标准jdbc的DatabaseMetaData.getTables接口返回的"TABLE_NAME"字段的内容 需要按实际值填写 splitField 划分分片的列名 需要选取取值为整型的列，建议选取重复值少分布均匀的列，以便划分出均匀的分片 calcStepEnable 是否需要动态调整分片的区间取值范围 对存在数据变更的数据表设置为"true” dataReadOnly 是否是只读数据表 对只读数据表设置为"true” splitCount 读取数据分片的并发数 请按调优的最佳取值来填写 fieldMinValue splitField字段的最小值 对只读数据表建议按查询结果来配置，否则填"“或“null” fieldMaxValue splitField字段的最大值 对只读数据表建议按查询结果来配置，否则填"“或“null”
属性参考 本节将介绍最重要的配置属性，这些属性可用于调优openLooKeng或在需要时更改其行为。 通用属性 join-distribution-type 类型： string 允许值： AUTOMATIC，PARTITIONED，BROADCAST 默认值： AUTOMATIC 要使用的分布式联接的类型。 设置为PARTITIONED时，openLooKeng将使用哈希分布式联接。 当设置为BROADCAST时，将向集群中所有从左表获得数据的节点广播右表。分区联接要求使用联接键的哈希重分布这两个表。这可能比广播联接慢（有时极慢），但允许更大的联接。特别是如果右表比左表小得多，则广播联接将更快。 但是广播联接要求联接右侧过滤后的表适合每个节点的内存，而分布式联接只需要适合所有节点的分布式内存。当设置为AUTOMATIC时，openLooKeng将基于成本决定哪种分布类型是最优的。还将考虑将左右输入切换到联接。 在AUTOMATIC模式中，如果无法计算成本，例如表没有统计信息，openLooKeng将默认哈希分布式联接。也可以使用join_distribution_type会话属性在每个查询基础上指定。 redistribute-writes 类型： boolean 默认值： true 此属性允许在写入数据之前重新分布数据。这可以通过在集群中的节点间散列数据来消除数据倾斜带来的性能影响。当已知输出数据集没有发生倾斜时，可以停用数据分布，以避免在网络上散列和重分布所有数据的开销。也可以使用redistribute_writes会话属性在每个查询基础上指定。 stack-trace-visible 类型： boolean 允许值： true, false 默认值： false 此属性控制系统是否能够在CLI、WEB UI等对外展示系统出现Exception时的代码调用栈. 当设置为true时对外展示给所有用户，设置为false或者采用默认设置，不展示给任何用户。 openlookeng.admins 类型： string 默认值： 不设置 此属性用于设置admin用户，admin用户具有获取所有用户查询历史、下载所有用户WEB UI查询结果的权限。默认不设置admin用户，当需要设置多个admin用户时，多个用户间使用逗号隔开。 http 安全头部属性 http-header.content-security-policy 类型： string 默认值： object-src 'none' 此属性设置 content-security-policy 设置相关值。 http-header.
算子级别快照 概述 openLooKeng中的算子级别快照，会定期保存查询执行的完整状态的快照。发生错误时，查询可以从上一个成功的快照恢复执行。该实现基于标准Chandy-Lamport算法。 自版本1.2.0起，openLooKeng支持恢复任务和工作节点故障。 启用恢复框架 恢复框架对于长时间运行的查询最有用。默认禁用，可以使用会话属性recovery_enabled启用或禁用恢复框架。建议仅对可靠性要求高的复杂查询启用该功能。 要求 要从之前保存的快照恢复执行，必须有足够数量的可用工作节点，以便恢复所有任务。要对查询启用分布式快照，有以下要求： 至少2个工作节点 至少之前80%的可用工作节点(向下舍入)仍处于活动状态，以便恢复成功。如果没有足够的工作节点可用, 查询将不能使用任何之前成功的快照进行恢复，查询将从头重新运行。 限制 支持的语句：仅支持INSERT和CREATE TABLE AS SELECT类型的语句 不包括类似INSERT INTO CUBE的语句。 源表：只能从Hive目录中的表读取。 目标表：只能写入Hive目录中的表，格式为ORC。 与其他功能的交互：分布式快照目前无法与以下功能一起使用： 重用交换，即optimizer.reuse-table-scan 重用公用表表达式（CTE），即optimizer.cte-reuse-enabled 在启用分布式快照的情况下提交不满足上述要求的查询时，查询按未启用分布式快照功能的场景执行。 检测 当协调器与远程任务之间的通信长时间失败时，将触发错误恢复，由故障恢复处理属性配置控制。 存储注意事项 从保存的快照恢复查询执行时，任务可能会在与保存快照时不同的工作节点上调度。这意味着所有工作节点都必须能够访问保存的快照数据。 快照数据存储在使用hetu.experimental.snapshot.profile属性指定的文件系统中。 快照文件存储在文件系统的/tmp/hetu/snapshot/文件夹下。必须授权所有工作节点读取和写入此文件夹。 快照反映查询执行中的状态，可能会变得非常大，并且因查询而异。例如，需要缓冲大量数据的查询（通常涉及排序、窗口、连接、聚合等操作）可能会产生包含整个表数据的快照。执行前请确保共享文件系统有足够的可用空间来保存这些快照。 每次查询执行都可能生成多个快照。快照的内容可能会重叠。目前，快照以单独文件的形式存储。未来可能会引入“增量快照”功能，以节省存储空间。 性能开销 从错误和快照中恢复需要成本。捕获快照需要时间，时间长短取决于复杂性。因此，需要在性能和可靠性之间进行权衡。 建议在必要时打开快照捕获，例如对于长时间运行的查询。对于这些类型的工作负载，拍摄快照的开销可以忽略不计。 快照统计信息 在调试模式下启动CLI时，快照捕获信息和恢复信息将与查询结果一起显示在CLI中。 快照捕获统计信息包括捕获的快照数量、捕获的快照大小、捕获快照所需的CPU时间和在查询期间捕获快照所需的挂钟时间。所有快照和最后一个快照的统计信息会分别显示。 快照恢复信息包括查询期间从快照恢复的次数、加载用于恢复的快照大小、从快照恢复所需的CPU时间和从快照恢复所需的挂钟时间。仅当查询期间发生恢复时，才会显示恢复信息。 此外，在查询正在进行时，将显示捕获的快照数量和恢复的快照的ID。更多详细信息，见下图。 配置 与恢复框架功能相关的配置，请参见属性参考。
Task级别快照 概要 Task快照是另一种可靠查询机制，它是query重试查询和Operator快照重试的折中机制。与query重试查询相比，在发生故障后，通过Task快照进行Task粒度重试恢复，而不是整个query重新执行，效率更高。与Operator快照相比，Task粒度的快照空间占用更小，性能也更好。 默认情况下，查询失败后需要手动重试查询。openLooKeng中通过Task级别快照进行自动恢复来确保可靠的查询执行。Task级别快照启用后，查询过程中task之间的交换数据通过快照进行物化，当查询过程中Coordinator检测到worker发生故障或者task失败时，Coordinator调度空闲Worker读取故障worker最近保存的Task快照，然后自动恢复查询执行，这样可以保证查询的可靠性。对于耗时长的查询，将给用户更加确切的执行结果，更适合批处理场景。 启用Task级别快照 Task级别快照自动恢复机制，对于需要长时间运行的复杂查询最有效果。默认情况下处于禁用状态，可通过配置文件etc/config.properties中的配置属性retry-policy进行启用。 启动：retry-policy=TASK 停用：retry-policy=NONE 运行要求 为了确保查询执行通过Task快照能够自动恢复，保证查询执行的可靠性，集群需要满足以下要求： 启用Task级别快照特性 集群至少包含2个工作节点 除故障节点外，其他工作节点处于健康状态 限制 支持的语句：仅支持SELECT，INSERT和CREATE TABLE AS SELECT（CTAS）类型的语句，不包括类似INSERT INTO CUBE的语句。 数据源：只能从Hive目录中的数据表读取。 目标表：只能写入Hive目录中的表，格式为ORC。 特性互斥说明：Task快照功能和Operator快照功能不支持同时启用。 重试策略 当Coordinator和Worker之间的通信失败或超时，以及task执行失败时，将触发重试查询。相关故障重试的配置如下： 属性：task-retry-attempts-per-task 默认值：4 描述：重试返回失败前，单个Task允许的最大重试次数。 属性：task-initial-delay 默认值：10s 描述：Task在重试之前必须等待的最短时间。 属性：task-max-delay 默认值：1m 描述：Task在重试之前必须等待的最长时间。 Task快照的存储方式 查询过程中Task间的交换数据和状态，以Task快照的形式物化到文件系统中，其中文件系统支持两种类型：local和hdfs。当发生故障时，查询过程中Coordinator调度其他空闲的Worker节点从文件系统中的指定目录读取Task快照，进行数据再次加载和重试。因此，所有Worker节点都必须能够共享访问存储Task快照的文件系统，这样才可以进行正常的恢复。交换管理器通过配置文件etc/exchange-manager.properties进行共享文件系统的配置。相关属性如下： 属性：exchange-manager.name 描述：配置交换管理器的名称。 属性：exchange-filesystem-type 描述：存储Task快照的文件系统客户端名称。如果exchange-filesystem-type=exchange，名称为exchange客户端将用于存储查询执行产生的Task快照。文件系统客户端的配置文件路径etc/filesystem/exchange.properties（properties文件名需要和exchange-filesystem-type保持一致），参见交换文件系统客户端配置。 属性：exchange.base-directories 描述：文件系统的根目录，存储Task快照的起始文件路径。所有Worker节点都必须具备共享访问的权限。 属性：exchange.compression-enabled 描述：该属性启停Task快照的压缩功能。 请注意，Task快照用于保存Worker节点查询执行过程中，各Task之间的交换数据和状态。查询执行前确保集群有足够的空闲空间存储这些Task快照，查询完成后会自动清理来释放存储空间。
资源组 资源组限制资源使用，并可以对在其内部运行的查询执行排队策略，或在子组之间划分资源。一个查询属于单个资源组，并使用该组（及其祖先）的资源。除了对排队查询进行限制外，资源组耗尽资源时不会导致正在运行的查询失败；相反，新的查询将进入排队状态。资源组可以有子组，也可以接受查询，但不能同时执行两者。 资源组和关联的选择规则由可插拔的管理器配置。添加包含以下内容的etc/resource-groups.properties文件，使内置管理器能够读取JSON配置文件： resource-groups.configuration-manager=file resource-groups.config-file=etc/resource-groups.json 将resource-groups.config-file的值修改为指向一个JSON配置文件，可以是绝对路径，也可以是相对于openLooKeng数据目录的路径。 其他配置 除了etc/resource-groups.properties中的上述属性外，还可以配置以下两个属性，这些属性与kill策略一起使用（详细信息与kill策略的部分相同） resource-groups.memory-margin-percent（可选）-这是两个被认为相同的查询之间所允许的内存变化百分比。在此情况下，查询不会根据内存使用情况进行排序，而是根据查询执行进度进行排序，前提是查询进度差异大于配置差异。默认值为10%。 resource-groups.query-progress-margin-percent（可选）-这是两个被认为相同的查询之间所允许的查询执行进度百分比。在此情况下，查询不会根据执行进度进行排序。默认值为5%。 资源组属性 name（必填）：群组名称。可以是模板（见下文）。 maxQueued（必填）：最大排队查询数。一旦达到此限制，新的查询将被拒绝。 hardConcuritiesLimit（必填）：最大运行查询数。 softMemoryLimit（必填）：新查询进入队列之前，该组可以使用的最大分布式内存量。可指定为集群内存的绝对值（如1GB）或百分比（如10%）。 softCpuLimit（可选）：在对最大运行查询数进行惩罚之前的时间内（参见cpuQuotaPeriod），该组可能使用的最大CPU时间。同时必须指定hardCpuLimit。 hardCpuLimit（可选）：该组在一段时间内可能使用的最大CPU时间。 schedulingPolicy（可选）：指定如何选择运行排队的查询，以及子组如何成为符合条件的查询。可以配置为以下三种策略之一。当集群开启高可用模式（多个coordinator）时，仅支持fair调度策略： fair（默认）：排队的查询按先进先出的顺序处理，子组必须轮流启动新查询（如果它们有排队的话）。 weighted_fair：根据子组的schedulingWeight和子网并发的查询数量选择子组。子组正在运行的查询预期份额基于当前所有符合条件的子组权重计算。选择与其份额相比并发数最小的子组开始下一次查询。 weighted：按照优先级（通过query_priority会话属性指定）的随机选择排队的查询。按照schedulingWeight的比例选择子组以启动新查询。 query_priority：所有子组都必须配置query_priority。排队的查询将严格按照其优先级进行选择。 schedulingWeight（可选）：该子组的权重。参见上文。默认为1。 jmxExport（可选）：如果为true，则导出群组统计信息到JMX进行监控。默认为false。 subGroups（可选）：子组列表。 killPolicy（可选）：当查询提交给worker后，如果总内存使用量超过softMemoryLimit，选择其中一种策略终止正在运行的查询。 no_kill（默认值）：不终止查询。 recent_queries：根据执行顺序的倒序进行查询终止。 oldest_queries：根据执行顺序进行查询终止。 high_memory_queries：根据内存使用量进行查询终止。具有较高内存使用量的查询将首先被终止，以便在查询终止次数最少的情况下，释放更多内存。 作为此策略的一部分，我们尝试平衡内存使用量和完成百分比。因此，如果两个查询的内存使用量都在限制的10%以内（可通过resource-groups.memory-margin-percent配置），则进度慢（执行的百分比）的查询被终止。如果这两个查询在完成百分比方面的差异在5%以内（可通过resource-groups.query-progress-margin-percent配置），则内存使用量大的查询被终止。 finish_percentage_queries：根据查询执行百分比进行查询终止。执行百分比最小的查询将首先被终止。 选择器规则 user（可选）：用于匹配用户名的正则表达式。 source（可选）：用于匹配源字符串的正则表达式。 queryType（可选）：用于匹配提交的查询类型的字符串。 DATA_DEFINITION：修改/创建/删除模式/表/视图的元数据，以及管理预备语句、权限、会话和事务的查询。 DELETE：DELETE查询。 DESCRIBE：DESCRIBE、DESCRIBE INPUT、DESCRIBE OUTPUT以及SHOW查询。 EXPLAIN：EXPLAIN查询。 INSERT：INSERT和CREATE TABLE AS查询。 SELECT：SELECT查询。 clientTags（可选）：标签列表。为了能成功匹配，此列表中的每个标签都必须在客户端提供的与查询关联的标签列表中。 group（必填）：这些查询将运行的组。 选择器按顺序处理，并将使用第一个匹配的选择器。
会话属性管理器 管理员可以添加会话属性来控制其工作负载子集的行为。这些属性是默认属性，可以被用户重写（如果被授权）。会话属性可用于控制资源使用、启用或禁用特性以及更改查询特性。会话属性管理器可插拔。 添加具有如下内容的etc/session-property-config.properties文件使内置管理器可以读取JSON配置文件： session-property-config.configuration-manager=file session-property-manager.config-file=etc/session-property-config.json 将session-property-manager.config-file的值修改为指向一个json配置文件，可以是绝对路径，也可以是相对于openLooKeng数据目录的相对路径。 此配置文件由匹配规则列表和默认情况下应应用的会话属性列表组成，每条匹配规则指定查询必须满足的条件列表。所有匹配规则都有助于构造会话属性列表。规则按指定的顺序应用。文件中较晚指定的规则将重写以前遇到的属性的值。 匹配规则 user（可选）：用于匹配用户名的正则表达式。 source（可选）：用于匹配源字符串的正则表达式。 queryType（可选）：用于匹配提交的查询类型的字符串： DATA_DEFINITION：更改/创建/删除模式/表/视图的元数据，以及管理预备语句、权限、会话和事务的查询。 DELETE：DELETE查询。 DESCRIBE：DESCRIBE、DESCRIBE INPUT、DESCRIBE OUTPUT以及SHOW查询。 EXPLAIN：EXPLAIN查询。 INSERT：INSERT和CREATE TABLE AS查询。 SELECT：SELECT查询。 clientTags（可选）：标签列表。要匹配，此列表中的每个标记都必须在客户端提供的与查询关联的标记列表中。 group（可选）:用于匹配查询路由到的资源组的完全限定名的正则表达式。 sessionProperties：与字符串键和值的映射。每个条目是系统或目录属性名和相应的值。值必须指定为字符串，而不管实际的数据类型是什么。 示例 考虑以下一组要求： 在global资源组下运行的所有查询的执行时间限制必须为8小时。 所有交互查询都路由到global.interactive组下的子组，并且执行时间限制为1小时（比对global的约束更严格）。 所有ETL查询（标记为‘etl’）都被路由到global.pipeline组下的子组，并且必须用某些属性配置以控制编写器行为。 这些要求可以用以下规则来表达： [ { "group": "global.*", "sessionProperties": { "query_max_execution_time": "8h", } }, { "group": "global.interactive.*", "sessionProperties": { "query_max_execution_time": "1h" } }, { "group": "global.pipeline.*", "clientTags": ["etl"], "sessionProperties": { "scale_writers": "true", "writer_min_size": "1GB" } } ]
溢出到磁盘 概述 对于内存密集型操作，openLooKeng允许将中间操作结果卸载到磁盘。此机制的目标是执行需要超过每个查询或每个节点限制的内存量的查询。 这种机制类似于操作系统级的页面交换。但是，该机制是在应用程序级别实现的，以满足openLooKeng的特定需要。 与溢出相关的属性在tuning-spilling中描述。 内存管理与溢出 默认情况下，如果查询执行所请求的内存超过会话属性query_max_memory或query_max_memory_per_node，openLooKeng将终止查询。这种机制保证了查询内存分配的公平性，避免了内存分配导致的死锁。当集群中有大量小查询时，效率很高，但是会导致超出限制的大型查询被终止。 为了克服这种低效率，引入了可回收内存的概念。查询可以请求不计入限制的内存，但内存管理器可以随时回收该内存。当内存被回收时，查询运行程序将中间数据从内存溢出到磁盘并稍后继续处理。 在实际中，当集群空闲且所有内存都可用时，内存密集型查询可能会使用集群中的所有内存。另一方面，当集群没有太多空闲内存时，相同的查询可能被迫使用磁盘作为中间数据的存储。与完全在内存中运行的查询相比，强制溢出到磁盘的查询的执行时间可能会长上几个数量级。 请注意，启用溢出到磁盘并不保证执行所有内存密集型查询。查询运行程序仍然可能无法将中间数据划分为足够小的块使每个块都适合放入内存，从而导致从磁盘加载数据时导致Out of memory错误。 可回收内存和保留池 保留内存池和可回收内存都是为了应对低内存条件而设计的。当用户内存池耗尽时，单个查询将提升到保留池。在这种情况下，只允许该查询进行，从而降低集群并发性。可回收内存将试图通过触发溢出来防止这种情况发生。保留池的大小为query_max_memory_per_node。这意味着，当query_max_memory_per_node较大，那么用户内存池可能比query_max_memory_per_node小得多。对于每个节点都需要消耗大量内存的查询，这将导致过多的溢出。当溢出被禁用时，这些查询可以更快地完成，因为它们在保留池中执行。在这种情况下，我们建议通过experimental.reserved-pool-enabled配置属性禁用保留内存池。 溢出磁盘空间 将中间结果溢出到磁盘并将其取回对于I/O操作来说代价较高。因此，使用溢出的查询可能会受到磁盘的限制。为了提高查询性能，建议在单独的本地设备上提供多个路径用于溢出（tuning-spilling中的属性spiller-spill-path）。 不应使用系统驱动器来溢出，尤其是不要溢出到JVM正在运行并写日志的驱动器上。这样做可能导致集群不稳定。另外，建议对配置的溢出路径进行磁盘饱和度监控。 openLooKeng将溢出路径视为独立的磁盘（参见JBOD），因此无需使用RAID进行溢出。 溢出到HDFS 操作可以直接溢出到HDFS。将experimental.spiller-spill-to-hdfs设置为true，配置experimental.spiller-spill-profile，并且spiller-spill-path必须仅包含一个目录。（更多详情请参见experimental.spiller-spill-to-hdfs和experimental.spiller-spill-profile属性） 溢出压缩 当启用溢出压缩（tuning-spilling中的spill-compression-enabled属性）时，溢出页将被压缩后再写入磁盘。启用此特性可以减少磁盘I/O，但会牺牲额外的CPU负载来压缩和解压缩溢出页。 溢出加密 当启用溢出加密（tuning-spilling中的spill-encryption-enabled属性）时，溢出内容将使用随机生成的（每个溢出文件）密钥进行加密。启用此功能将增加CPU负载并降低溢出到磁盘的吞吐量，但可以防止溢出的数据从溢出文件中恢复。考虑在启用溢出加密时减小experimental.memory-revoking-threshold的值，以应对溢出延迟的增加。 支持操作 并不是所有的操作都支持溢出到磁盘，并且每个操作的处理也不同。目前对以下操作实现该机制。 联接 在联接操作期间，正在联接的表之一存储在内存中。此表称为构建表。如果来自另一表的行与构建表中的行匹配，则这些行将串流并传递到下一个操作。联接中占用内存最多的部分是这个构建表。 当任务并发度大于1时，对构建表进行分区。分区个数与task.concurrency配置参数（参见task-properties）的值一致。 在对构建表进行分区时，溢出到磁盘机制可以减少联接操作所需的峰值内存使用。当查询接近内存限制时，构建表的分区的一个子集会溢出到磁盘，另一表的行也会溢出到这些分区。溢出的分区数量会影响所需的磁盘空间量。然后，逐个回读溢出分区以完成联接操作。 通过这种机制，联接操作符使用的峰值内存可以降低到最大构建表分区的大小。假设没有数据倾斜，这个值将是整个构建表大小的1 / task.concurrency倍。 注意：spill-to-disk不支持交叉连接。 聚合 聚合函数对一组值执行操作并返回一个值。如果要聚合的组数量很大，可能需要大量内存。当启用溢出到磁盘时，如果没有足够的内存，则中间累积的聚合结果将写入磁盘。结果被重新加载回来，并以较低的内存占用量合并。 排序 如果尝试对大量数据进行排序，可能需要大量内存。当启用为排序溢出到磁盘时，如果内存不足，则中间排序结果将写入磁盘。结果被重新加载回来，并以较低的内存占用量合并。 通常，当溢出正在进行时，运算符将被阻止接受输入，但当experimental.spill-non-blocking-orderby设置为true时，使用异步机制溢出（请参见experimental.spill-non-blocking-orderby）。 开窗函数 开窗函数在运算过程中对每一行输入数据进行计算,并为每一行数据返回一个开窗计算结果；如果开窗计算数据量较大，超出内存配置，在开启溢写磁盘spill_window_operator=true配置,能保证在内存不足时，开窗计算过程中的排序结果数据溢写到磁盘；当内存可用时，将溢写数据加载到内存进行合并。目前有一个限制，即溢出不会在所有情况下生效，例如当单个窗口非常大时。 复用交换 在复用交换优化期间，某个表读取操作缓存超过特定阈值的数据可能会暂时溢出到磁盘，并由将来的表读取操作回读。这样可以确保即使数据正在缓存，查询的内存占用量也不会无限制增加。当查询完成、失败或中止时，溢出的数据将被删除。
状态存储 本节介绍openLooKeng状态存储. 状态存储用于存储状态,状态被状态存储成员和状态存储客户端共享。 状态存储集群由状态存储成员组成，状态存储客户端可以执行所有状态存储操作而无需成为集群的成员。 强烈建议将协调节点配置为状态存储成员，将工作节点配置为状态存储客户端。 使用 当前状态存储被用于HA和动态过滤功能特性。 配置状态存储 配置状态存储成员 添加 hetu.embedded-state-store.enabled=true 到 etc/config.properties。 配置状态存储属性, 参考下方配置状态存储属性。 配置状态存储客户端 配置状态存储属性, 参考下方配置状态存储属性。 配置状态存储属性 目前有2种方法配置状态存储属性 TCP-IP : 状态存储成员根据种子（即状态存储成员ip地址）相互发现。 Multicast : 状态存储成员在同一网络下相互发现。 不建议在生产环境中使用Multicast机制，因为UDP通常在生产环境中被阻止。 TCP-IP方法配置状态存储属性 在状态存储成员和状态存储客户端安装目录中创建文件etc\state-store.properties。 state-store.type=hazelcast state-store.name=query state-store.cluster=cluster1 hazelcast.discovery.mode=tcp-ip hazelcast.discovery.port=5701 #在hazelcast.discovery.tcp-ip.seeds或者hazelcast.discovery.tcp-ip.profile配置任选其一 hazelcast.discovery.tcp-ip.seeds=<member1_ip:member1_hazelcast.discovery.port>,<member2_ip:member2_hazelcast.discovery.port>,... hazelcast.discovery.tcp-ip.profile=hdfs-config-default 上述属性说明如下： state-store.type：状态存储的类型。目前仅支持Hazelcast。 state-store.name：用户定义的状态存储名称。 state-store.cluster：用户定义的状态存储集群名称。 hazelcast.discovery.mode : Hazelcast状态存储发现模式, 目前支持tcp-ip和multicast（默认）。 hazelcast.discovery.port : 用户定义hazelcast启动端口。该属性可选，默认端口为5701。只需状态存储成员配置该项。 hazelcast.discovery.tcp-ip.seeds : 状态存储成员种子列表用来启动状态存储集群。 hazelcast.discovery.tcp-ip.profile : 共享存储配置文件的名称，可被状态存储成员和状态存储客户端共同访问。目前只支持文件系统配置文件, 参考下方文件系统属性。 说明：如果状态存储成员的ip地址是静态的，请配置“ hazelcast.discovery.tcp-ip.seeds”。 如果状态存储成员的ip地址是动态变化的，则用户可以配置“ hazelcast.discovery.tcp-ip.profile”，其中状态存储成员会自动将其ip：port存储在共享存储中，发现彼此。 如果两者同时被配置，“ hazelcast.
openLooKeng调优 默认openLooKeng设置对于大多数工作负载应该可以正常工作。如果你的集群面临特定的性能问题，以下信息可能会有帮助。 配置属性 参见属性参考。 JVM设置 诊断GC问题时，以下信息可能会有帮助: -XX:+PrintGCApplicationConcurrentTime -XX:+PrintGCApplicationStoppedTime -XX:+PrintGCCause -XX:+PrintGCDateStamps -XX:+PrintGCTimeStamps -XX:+PrintGCDetails -XX:+PrintReferenceGC -XX:+PrintClassHistogramAfterFullGC -XX:+PrintClassHistogramBeforeFullGC -XX:PrintFLSStatistics=2 -XX:+PrintAdaptiveSizePolicy -XX:+PrintSafepointStatistics -XX:PrintSafepointStatisticsCount=1 性能调优说明 下面是一些有助于优化查询执行性能的配置说明。 公共表表达式（CTE） 优化 公共表表达式是查询执行计划中被多次用到的公共子执行计划。 openLooKeng分析引擎评估CTE计划节点的使用情况，以确定CTE重用优化的可行性。这个优化在两个场景下被应用： 重用执行管道 如果配置 optimizer.cte-reuse-enabled：一个给定查询里的相同CTE计划节点被安排到stage管道中，并且只有一个CTE节点（生产者）被执行，其他的CTE节点（消费者）复用第一个CTE节点的输出结果。 当CTE用于自连接（self join）时，那么CTE管道不可用。 管道模式执行减少了重复的数据扫描和数据处理，从而减少了查询的执行时间。 物化和重用 如果配置 enable-cte-result-cache：CTE结果将物化到用户指定的存储位置(由数据缓存配置指定)。这里缓存了CTE节点的输出结果，物化成功后，可被后续的查询读取和重用。 执行计划优化 使用精确的分区：启用后，除非上游阶段的分区精确地匹配到下游阶段的分区，否则强制对数据重新分区（参考: 精准分区）。 自适应聚合: 该特性可以自适应地进行部分聚合； 该特性受到以下三个配置控制： 启用自适应部分聚合：启用特性。 最小行数阈值：可能自适应关闭部分聚合的最小处理数据行数。 唯一行数比值：可能自适应关闭部分聚合的聚合输出、输入数据行数的比值。 join数据独立性假设下的选择率估计: 多子句join下数据独立性因子：多子句连接的选择率估计的数据独立性假设因子。 多过滤条件下数据独立性因子：多过滤条件的选择率估计的数据独立性假设因子。 执行策略：指定调度器实施的执行策略，配置可参考指定执行策略： all-at-once：该策略下调度器启动和处理所有的阶段。 phased：该策略下调度器调度遵循阶段间生产者源这样的依赖关系，可以将所有独立的阶段一起调度。 prioritize-utilization：该策略下调度器调度除了遵循生产者源这样的阶段依赖关系以外，它还查看动态过滤生产者的依赖路径。
Web界面 openLooKeng提供了一个用于监视和管理查询的Web界面。Web界面可以在openLooKeng协调节点上通过HTTP协议访问，使用协调节点config.properties中指定的HTTP端口号。 主页有一个查询列表，其中包含诸如唯一查询ID、查询文本、查询状态、完成百分比、用户名和该查询的来源等信息。当前运行的查询位于页面的顶部，紧随其后的是最近完成或失败的查询。 可能的查询状态如下： QUEUED–查询已被接受，等待执行。 PLANNING–查询正在规划中。 STARTING–查询执行开始。 RUNNING–查询中至少有一个正在运行的任务。 BLOCKED–查询阻塞，等待资源（缓冲区空间、内存、分片等）。 FINISHING–查询正在结束（例如：提交自动提交查询）。 FINISHED–查询已经执行完成，所有输出已经消耗。 FAILED–查询执行失败。 BLOCKED状态是正常的，但如果该状态持续，应进行调查。该状态有很多可能的原因：内存或分片不足、磁盘或网络I/O瓶颈、数据倾斜（所有数据都流向几个工作节点）、缺乏并行度（只有几个工作节点可用）或给定阶段之后的查询的计算开销大。另外，如果客户端处理数据的速度不够快，查询可能处于BLOCKED状态（常见于“SELECT *”查询）。 有关查询的详细信息，请单击查询ID链接。查询详细信息页有一个摘要部分、查询的各个阶段的图形表示和任务列表。可以点击每个任务ID以获得有关该任务的更多信息。 摘要部分有一个按钮，用于终止当前正在运行的查询。在摘要部分有两个可视化：任务执行和时间线。通过单击JSON链接，可以获得包含有关查询的信息和统计信息的完整JSON文档。这些可视化和其他统计信息可用于分析查询所花费的时间。 通用属性 hetu.queryeditor-ui.allow-insecure-over-http 类型: boolean 允许值 true, false 默认值: false 默认情况下，基于HTTP的非安全环境禁用WEB UI。可以通过配置etc/config.properties文件的hetu.queryeditor-ui.allow-insecure-over-http属性启用(例子: hetu.queryeditor-ui.allow-insecure-over-http=true)。 hetu.queryeditor-ui.execution-timeout 类型： duration 默认值： 100 DAYS UI执行超时默认设置为100天。可以通过配置etc/config.properties文件中的hetu.queryeditor-ui.execution-timeout属性修改。 hetu.queryeditor-ui.max-result-count 类型： int 默认值： 1000 UI最大结果计数默认设置为1000。可以通过配置etc/config.properties文件中的hetu.queryeditor-ui.max-result-count属性修改。 hetu.queryeditor-ui.max-result-size-mb 类型： size 默认值： 1GB UI最大结果大小默认设置为1 GB。可以通过配置etc/config.properties文件中的hetu.queryeditor-ui.max-result-size-mb属性修改。 hetu.queryeditor-ui.session-timeout 类型： duration 默认值： 1 DAYS UI会话超时默认设置为1天。可以通过配置etc/config.
CarbonData连接器 概述 CarbonData连接器支持查询存储在CarbonData仓库中的数据。CarbonData由三个组件组成： CarbonData存储格式的数据文件，一般存储在Hadoop分布式文件系统（HDFS）中。 该元数据仅用于表和列模式验证。carbondata元数据与数据文件存储在一起，通过Hive Metastore Service (HMS)访问。 一种称为HiveQL/SparkSQL的查询语言。这种查询语言在分布式计算框架（如MapReduce或Spark）上执行。 openLooKeng只使用前两个组件：数据和元数据。它不使用HiveQL/SparkSQL或Hive的任何部分执行环境。 说明： openLooKeng支持CarbonData 2.0.1。 配置 Carbondata连接器支持Apache Hadoop 2.x及以上版本。 用以下内容创建etc/catalog/carbondata.properties，以将carbondata连接器挂载为carbondata目录，将example.net:9083替换为Hive元存储 Thrift服务的正确主机和端口： connector.name=carbondata hive.metastore.uri=thrift://example.net:9083 HDFS配置 对于基本设置，openLooKeng自动配置HDFS客户端，不需要任何配置文件。在某些情况下，例如使用联邦HDFS或NameNode高可用性时，需要指定额外的HDFS客户端选项，以便访问HDFS集群。要指定选项，添加hive.config.resources属性来引用HDFS配置文件： hive.config.resources=/etc/hadoop/conf/core-site.xml,/etc/hadoop/conf/hdfs-site.xml,/etc/hadoop/conf/yarn-site.xml,/etc/hadoop/conf/mapred-site.xml 如果设置需要，只指定附加的配置文件。同时建议减少配置文件，使其具有所需的最小属性集，因为附加属性可能导致问题。 所有openLooKeng节点上必须存在配置文件。如果用户正在引用现有的Hadoop配置文件，请确保将其复制到任何没有运行Hadoop的openLooKeng节点。 HDFS用户名和权限 在对CarbonData表执行任何CREATE TABLE或CREATE TABLE AS语句之前，openLooKeng应该能够访问Hive和HDFS。Hive的仓库目录由hive-site.xml中的配置变量hive.metastore.warehouse.dir指定，默认值为/user/hive/warehouse。 在不使用带HDFS的Kerberos时，openLooKeng会使用openLooKeng进程的操作系统用户来访问HDFS。例如，如果openLooKeng作为nobody运行，则openLooKeng将作为nobody访问HDFS。可以通过在openLooKeng JVM配置中设置HADOOP_USER_NAME系统属性来覆盖此用户名，用适当的用户名替换hdfs_user： -DHADOOP_USER_NAME=hdfs_user hive用户通常可行，因为Hive通常随hive用户启动，并且该用户可以访问Hive仓库。 无论何时修改openLooKeng访问HDFS的用户时，请移除HDFS上的/tmp/openlookeng-*，/tmp/presto-*，/tmp/hetu-*，因为新用户可能无法访问现有的临时目录。 访问Kerberos身份验证保护的Hadoop集群 HDFS和Hive元存储都支持Kerberos身份验证。但是，目前还不支持通过票据缓存进行Kerberos身份验证。 CarbonData连接器安全需要的属性在CarbonData配置属性表中列出。有关安全选项的更详细的讨论，请参阅Hive安全配置部分。 Carbondata配置属性 属性名称 说明 默认值 carbondata.store-location CarbonData仓库的存储位置。如果不指定，则使用默认的Hive仓库路径，即 /user/hive/warehouse/carbon.store ${hive.metastore.warehouse.dir} /carbon.store carbondata.minor-vacuum-seg-count 指定可考虑对Carbondata表进行Minor Vacuum的段数。如果未指定或设置为小于2的数，则考虑所有可用段。 NONE carbondata.major-vacuum-seg-size 指定对Carbondata表进行Major Vacuum的大小限制，单位为GB。累计大小小于此阈值的所有段都将纳入考虑范围。如果未指定，则使用默认清空值，即1GB。 1GB hive.
ClickHouse连接器 概述 Clickhouse连接器允许在外部ClickHouse数据库中查询和创建表。这可用于在ClickHouse和Hive等不同系统之间或在两个不同的ClickHouse实例之间联接数据。 配置 基础配置 要配置ClickHouse连接器，在etc/catalog中创建一个目录属性文件，例如clickhouse.properties，将ClickHouse连接器挂载为clickhouse目录。使用以下内容创建文件，并根据设置替换连接属性。 基本属性设置： connector.name=clickhouse connection-url=jdbc:clickhouse://example.net:8123 connection-user=username connection-password=yourpassword 是否允许连接器删除表 allow-drop-table=true 是否开启查询下推功能。 连接器的下推功能默认打开，也可以如下设置： clickhouse.query.pushdown.enabled=true 是否区分表名大小写 与openLooKeng不同，ClickHouse的语法是大小写敏感的，如果您的数据库表中存在大写字段，可以按如下设置。 case-insensitive-name-matching=true 多套ClickHouse数据库或服务器 可以根据需要创建任意多的目录，因此，如果有额外的ClickHouse服务器，只需添加另一个不同的名称的属性文件到etc/catalog中（确保它以.properties结尾）。例如，如果将属性文件命名为clickhouse2.properties，openLooKeng将使用配置的连接器创建一个名为clickhouse2的目录。 通过openLooKeng查询ClickHouse 通过SHOW SCHEMAS来查看可用的ClickHouse数据库： SHOW SCHEMAS FROM clickhouse; 如果有一个名为data的ClickHouse数据库，可以通过执行SHOW TABLES查看数据库中的表： SHOW TABLES FROM clickhouse.data; 若要查看数据模式中名为hello的表中的列的列表，请使用以下命令中的一种： DESCRIBE clickhouse.data.hello; SHOW COLUMNS FROM clickhouse.data.hello; 你可以访问数据模式中的hello表： SELECT * FROM clickhouse.data.hello; 如果对目录属性文件使用不同的名称，请使用该目录名称，而不要使用上述示例中的clickhouse。 openLooKeng和ClickHouse之间的映射数据类型 ClickHouse到openLooKeng类型映射 下表显示了ClickHouse数据类型到openLooKeng的映射关系。 数据类型映射表： ClickHouse类型 openLooKeng类型 说明 Int8 TINYINT Int16 SMALLINT Int32 INTEGER Int64 BIGINT float32 REAL float64 DOUBLE DECIMAL(P,S) DECIMAL(P,S) DECIMAL32(S) DECIMAL(P,S) DECIMAL64(S) DECIMAL(P,S) DECIMAL128(S) DECIMAL(P,S) String VARCHAR DateTime TIMESTAMP Fixedstring(N) CHAR UInt8 SMALLINT UInt16 INT UInt32 BIGINT UInt64 BIGINT Int128,Int256,UInt256 不涉及 openLooKeng到ClickHouse类型映射 下表显示了从openLooKeng到ClickHouse数据类型的映射关系。
DM(达梦数据库)连接器 概述 DM连接器允许在外部DM数据库中查询和创建表。这可用于在DM和Hive等不同系统之间或在两个不同的DM实例之间联接数据。 配置 首先，在开始使用DM连接器之前，应该先完成以下步骤： 用于连接DM的JDBC连接详情 要配置DM连接器，在etc/catalog中创建一个目录属性文件，例如dameng.properties。使用以下内容创建文件，并根据设置替换连接属性： connector.name=dameng connection-url=jdbc:dm://主机:端口/SYSDBA connection-user=用户名 connection-password=密码 添加DM的JDBC驱动 DM JDBC驱动不在普通存储库中提供，如果您是DM数据库的用户，您可以选择前往DM官方网站，在确保遵守DM JDBC驱动所适用的license的条件下，下载和安装DM JDBC驱动到存储库中。DM JDBC驱动（DmJdbcDriverX.jar X为数字，根据DM的版本不同而不同）可能会作为DM客户端安装的一部分进行安装。获取了DM JDBC驱动后，您可以将jdbc jar文件部署到协调节点和工作节点上的openLooKeng插件文件夹中。例如，jdbc驱动文件为DmJdbcDriverX.jar，openLooKeng插件包文件夹为 /opt/hetu-server/plugin，则拷贝命令如下： cp DmJdbcDriverX.jar /opt/hetu-server/plugin/dm。重启协调节点和工作节点进程，DM连接器即可正常工作。 是否开启查询下推功能 如果要启用DM连接器的连接器下推功能，不需要做任何操作，DM连接器的下推功能默认是打开的。但也可以按如下设置： jdbc.pushdown-enabled=true #true表示打开下推，false表示关闭。 下推模式选择。 如果要启用DM连接器的全部下推功能，不需要做任何操作，DM连接器的下推模式默认是全部下推的。但也可以按如下设置： jdbc.pushdown-module=FULL_PUSHDOWN #FULL_PUSHDOWN，表示全部下推；BASE_PUSHDOWN，表示部分下推，其中部分下推是指filter/aggregation/limit/topN/project这些可以下推。 更多配置 由于达梦数据库和Oracle同源，在实现DM连接器时，复用了Oracle连接器的部分配置，具体配置可参考ORACLE。 通过openLooKeng查询DM 对于名为dameng的DM连接器，每个DM数据库的用户都可以通过DM连接器获取其可用的模式，命令为SHOW SCHEMAS： SHOW SCHEMAS FROM dameng; 如果已经拥有了可用模式，可以通过SHOW TABLES命令查看名为data的DM数据库拥有的表： SHOW TABLES FROM dameng.data; 若要查看数据模式中名为hello的表中的列的列表，请使用以下命令中的一种： DESCRIBE dameng.data.hello; SHOW COLUMNS FROM dameng.data.hello; 你可以访问数据模式中的hello表： SELECT * FROM dameng.
数据中心连接器 数据中心连接器允许查询远程openLooKeng数据中心。可实现来自本地openLooKeng环境的不同openLooKeng集群之间的数据融合分析。 本端连接器配置 配置数据中心连接器时，在etc/catalog中创建一个属性文件，例如<dc-name>.properties，即将数据中心连接器挂载到<dc-name> 目录。使用以下内容创建配置文件，并根据实际的远端openLooKeng替换connection属性： 基本配置 connector.name=dc connection-url=http://example.net:8080 connection-user=<远端openLooKeng用户名> connection-password=<远端openLooKeng密码> 属性名称 说明 是否必选 默认值 connection-url 需要连接的openLooKeng的URL 必选 connection-user 需要连接的openLooKeng的用户名 可选 connection-password 需要连接的openLooKeng的密码 可选 安全配置 当远端openLooKeng开启了安全认证或TLS/SSL通道加密时，则需要在<dc-name>.properties进行相应的安全配置。 Kerberos认证方式 属性名称 说明 默认值 dc.kerberos.config.path Kerberos配置文件 dc.kerberos.credential.cachepath Kerberos凭证缓存 dc.kerberos.keytab.path Kerberos keytab文件 dc.kerberos.principal 向openLooKeng协调节点进行身份验证时使用的主体 dc.
Elasticsearch连接器 概述 Elasticsearch连接器允许从openLooKeng访问Elasticsearch数据。本文档主要介绍如何搭建Elasticsearch连接器来对Elasticsearch执行SQL查询。 注意：强烈推荐使用Elasticsearch 6.0.0及以上版本。 配置 要配置Elasticsearch连接器，请创建具有以下内容的目录属性文件etc/catalog/elasticsearch.properties，并适当替换以下属性： connector.name=elasticsearch elasticsearch.host=localhost elasticsearch.port=9200 elasticsearch.default-schema-name=default 配置属性 elasticsearch.host 定义连接Elasticsearch节点的主机。 此属性是必选。 elasticsearch.port 定义连接Elasticsearch节点的端口号。 此属性是可选的；默认值为9200。 elasticsearch.default-schema-name 定义将包含没有限定模式名称的所有表的模式。 此属性是可选的；默认值为default。 elasticsearch.pushdown.enabled 配置是否启用算子下推功能 默认情况下Elasticsearch连接器的算子下推功能是关闭的。你可以通过如下设置来启用它： elasticsearch.pushdown.enabled=true #true indicates that pushdown is enabled, and false indicates that pushdown is disabled. 注意：目前算子下推仅支持部分SQL语句的查询关键字，包括EQUAL、AND、OR、算数运算符、BETWEEN、IN，以及部分聚合语法，包括GROUP BY、SUM、COUNT方法。 数据结构算子下推支持矩阵: Elasticsearch openLooKeng 聚合 查询 binary VARBINARY 否 否 boolean BOOLEAN 是 是 double DOUBLE 是 是 float REAL 是 是 byte TINYINT 是 是 short SMALLINT 是 是 integer INTEGER 是 是 long BIGINT 是 是 keyword VARCHAR 是 是 text VARCHAR 否 是 date TIMESTAMP 是 是 ip IPADDRESS 是 是 (其他类型) 否 否 说明
Greenplum Connector Greenplum Connector 可以用来在一个外部的Greenplum数据库进行数据查询、创建表格等。 还可以用来作跨数据源的数据join处理，不需要额外的数据迁移操作，例如hive、Greenplum数据源之间的数据join操作，或者两个不同的Greenplum数据源之间的数据join操作。 Greenplum Connector是基于PostgreSQL connector开发的。同时我们在Greenplum connector中添加了Query Push Down特性。 配置项 Greenplum connector的基础配置和PostgreSQL connector是一样的。 比如你可以通过在etc/catalog中创建一个名为 greenplum.properties 的文件来在系统中加载一个Greenplum connector的实例。 这个文件中包含如下配置，你可以使用正确的配置值来替换下面配置项中的示意值。 connector.name=greenplum connection-url=jdbc:postgresql://example.net:5432/database connection-user=root connection-password=secret Table修改 我们可以在greenplum.properties中设置greenplum.allow-modify-table来声明是否允许Greenplum connector修改数据源SQL表格。 如果 greenplum.allow-modify-table 被设置成 false, create/rename/add column/rename column/drop column等操作都不能执行。 默认设置为true。 greenplum.allow-modify-table=true 在Greenplum connector中开启Query Push Down特性 Query Push Down特性能够把本来在openLooKeng中执行的filter, project 或者其他的一些 sql operators下推到Greenplum数据源执行， 这样可以减少openLooKeng和数据源之间的数据传输量。我们在greenplum.properties中配置jdbc.pushdown-enabled配置项来启动或者关闭这个特性。 如果jdbc.pushdown-enabled设置成 false, Query Push Down特性被关闭。 如果jdbc.pushdown-enabled设置成 true, Query Push Down特性被打开。 Query Push Down特性默认打开。 例如此配置项可以写成如下所示： jdbc.pushdown-enabled=false Query Push Down特性的模式选择 我们可以通过在greenplum.properties中配置jdbc.pushdown-module配置项来选择下推模式。 默认来说，我们系统使用的模式是BASE_PUSHDOWN.
Hana连接器 概述 Hana连接器允许在外部Hana数据库中查询和创建表。这可用于在Hana和Hive等不同系统之间或在两个不同的Hana实例之间联接数据。 配置 基础配置 首先，在开始使用Hana连接器之前，应该先完成以下步骤。 用于连接SAP HANA的JDBC连接详情 应该以常规openLooKeng连接器配置编写（例如名为hana的openLooKeng目录使用hana.properties）。文件应包含以下内容，并根据设置替换连接属性： 基本属性设置： connector.name=hana connection-url=jdbc:sap://主机:端口 connection-user=用户名 connection-password=密码 allow-drop-table=true #是否允许hana连接器丢弃表 添加SAP HANA驱动 SAP HANA JDBC驱动不在普通存储库中提供，因此需要从SAP HANA下载并手动安装到存储库中。SAP HANA JDBC驱动（ngdbc.jar）可能会作为SAP HANA客户端安装的一部分进行安装，或者从SAP HANA办公网站下载。获取了SAP HANA JDBC驱动后，就可以将jdbc jar文件部署到协调节点和工作节点上的openLooKeng插件文件夹中。例如，jdbc驱动文件为ngdbc.jar，openLooKeng插件包文件夹为 /usr/lib/presto/lib/plugin，则拷贝命令如下： cp ngdbc.jar /usr/lib/presto/lib/plugin/hana。重启协调节点和工作节点进程，hana连接器即可正常工作。 是否开启查询下推功能。 如果要启用hana连接器的连接器下推功能，不需要做任何操作，hana连接器的下推功能默认是打开的。但也可以按如下设置： jdbc.pushdown-enabled=true #true表示打开下推，false表示关闭。 下推模式选择。 如果要启用hana连接器的全部下推功能，不需要做任何操作，hana连接器的下推模式默认是全部下推的。但也可以按如下设置：
HBase连接器 概述 HBase连接支持在外部Apache HBase实例上查询和创建表。用户可以在HBase连接器中创建表，并映射到HBase Cluster中已有的表，支持insert、select和delete操作。 HBase连接器维护着一个元存储，用于持久化HBase元数据，目前元存储只支持以下存储格式：openLooKeng Metastore。 注意： Hbase连接器仅支持连接Apache HBase 2.2.3及以下的版本。 连接器配置 1 . 创建并编辑etc/catalog/hbase.properties，按需要替换下面xxx的值；connector.name是固定的；对于hbase.zookeeper.quorum的值，如果有多个IP地址，请使用逗号(,)作为分隔符。 connector.name=hbase-connector hbase.zookeeper.quorum=xxx.xxx.xxx.xxx,xxx.xxx.xxx.xxx hbase.zookeeper.property.clientPort=xxxx 2 . 使用openLooKeng元存储来存储HBase元数据 必须创建etc/hetu-metastore.properties来配置元数据存储平台，存储平台可选择RDBMS/HDFS。 配置举例： 创建并编辑 etc/hetu-metastore.properties 选择一：hetu-metastore配置为RDBMS： hetu.metastore.type=jdbc hetu.metastore.db.url=jdbc:mysql://xx.xx.xx.xx:3306/dbName.... hetu.metastore.db.user=root hetu.metastore.db.password=123456 选择二：hetu-metastore配置为HDFS： hetu.metastore.type=hetufilesystem # profile name of hetu file system hetu.metastore.hetufilesystem.profile-name=hdfs-config-metastore #the path of metastore storage in the hetu file system hetu.metastore.hetufilesystem.path=/etc/openlookeng/metastore 如果选择HDFS，接下来需要配置hetu filesystem（配置文件名称同上述profile-name保持一致，后缀为properties）。 创建并编辑 etc/filesystem/hdfs-config-metastore.properties fs.client.type=hdfs hdfs.config.resources=/opt/openlookeng/xxx/core-site.xml,/opt/openlookeng/xxx/hdfs-site.xml hdfs.authentication.type=NONE hdfs kerberos相关配置请参见filesystem 注意： 以上hbase.properties和hetu-metastore.properties两个配置文件缺一不可。如配置为HDFS，则另外需要hdfs-config-metastore.properties 可能遇到的问题：配置完成后，启动服务遇到“xxx路径（A配置文件）不在白名单列表”的错误 解决方案：选择日志中打印的白名单列表的一个目录，将所报错的路径下的文件，拷贝到该目录,并修改A配置文件中相应路径。 Kerberos配置： 如果HBase/Zookeeper是安全集群，则需要配置kerberos相关信息 hbase.jaas.conf.path=/opt/openlookeng/xxx/jaas.conf hbase.hbase.site.path=/opt/openlookeng/xxx/hbase-site.xml hbase.krb5.conf.path=/opt/openlookeng/xxx/krb5.conf hbase.
Hive连接器GCS教程 预先步骤 保证访问GCS Hadoop Cloud Storage连接器使得访问Cloud Storage数据成为可能。 如果数据是公开的，则无需任何操作。但是在大多数情况下，数据不是公开的，openLooKeng集群需要能够访问这些数据。这通常通过创建具有访问数据权限的服务账号来实现。可以在GCP中的服务账号页面上进行此操作。创建服务账号后，需要为其创建密钥，并下载JSON格式的密钥。 Hive连接器配置 另一个要求是已经在openLooKeng中启用并配置Hive连接器。连接器使用Hive元存储进行数据发现，不限于HDFS上的数据。 配置Hive连接器 Hive元存储地址： GCP上的新Hive元存储： 如果openLooKeng节点是由GCP提供的，那么Hive元存储也应该在GCP上，以将延迟和成本最小化。在GCP上创建新的Hive元存储的最简单方法是创建一个可以从openLooKeng集群访问的小型Cloud DataProc集群（1个主机，0个工作节点）。完成此步骤后，按照现有Hive元存储的步骤进行操作。 现有Hive元存储： 要使用通过openLooKeng集群使用现有Hive元存储，需要将Hive目录属性文件中的hive.metastore.uri属性设置为thrift://${METASTORE_ADDRESS}:${METASTORE_THRIFT_PORT}。如果元存储使用身份验证，请参考Hive安全配置。 GCS访问： 下面是可以在Hive目录属性文件中设置的所有GCS配置属性的示例值： # JSON key file used to access Google Cloud Storage hive.gcs.json-key-file-path=/path/to/gcs_keyfile.json # Use client-provided OAuth token to access Google Cloud Storage hive.gcs.use-access-token=false Hive元存储配置信息 如果Hive元存储使用StorageBasedAuthorization，那么还需要访问GCS来执行POSIX权限检查。为Hive配置GCS访问不在本教程的范围内。以下是有一些优秀的在线指南： Google：安装Cloud Storage连接器 HortonWorks：与Google Cloud Storage一起使用 Cloudera：配置Google Cloud Storage连接 GCS访问通常在core-site.xml中配置，供所有使用Apache Hadoop的组件使用。
Hive安全配置 授权 可以通过在Hive目录属性文件中设置hive.security属性来启用Hive的授权检查。此属性必须是下列值之一： 属性值 说明 legacy（默认值） 授权检查很少执行，因此大多数操作都是允许的。使用配置属性hive.allow-drop-table、hive.allow-rename-table、hive.allow-add-column、hive.allow-drop-column和hive.allow-rename-column。 read-only 允许读数据或元数据的操作（如SELECT），不允许写数据或元数据的操作（如CREATE、INSERT或DELETE）。 file 授权检查使用Hive配置属性security.config-file指定的配置文件来执行。有关详细信息，请参阅基于文件的授权。 sql-standard 按照SQL标准，只要用户具有所需的权限，就可以执行这些操作。在这种模式下，openLooKeng基于Hive元存储中定义的权限对查询执行授权检查。若要更改这些权限，使用GRANT和REVOKE命令。有关详细信息，请参阅基于SQL标准的授权。 基于SQL标准的授权 当启用sql-standard安全时，openLooKeng与Hive一样执行基于SQL标准的授权。 由于openLooKeng的ROLE语法支持符合SQL标准，而Hive并不完全遵循SQL标准，因此存在以下限制和差异： 不支持CREATE ROLE role WITH ADMIN。 必须启用admin角色才能执行CREATE ROLE或DROP ROLE。 不支持GRANT role TO user GRANTED BY someone。 不支持REVOKE role FROM user GRANTED BY someone。 默认在新的用户会话中，用户除角色admin外的所有角色都启用。 通过执行SET ROLE role可以选择特定的角色。 SET ROLE ALL启用用户除admin以外的所有角色。 admin角色必须通过执行SET ROLE admin显式启用。 身份验证 /connector/hive默认的安全配置在连接Hadoop集群时不使用身份验证。无论哪个用户提交查询，所有查询都以运行openLooKeng进程的用户执行。 Hive连接器提供了额外的安全选项来支持配置为使用Kerberos的Hadoop集群。 访问HDFS (Hadoop Distributed File System)时，openLooKeng可以模拟运行查询的最终用户。这可以与HDFS权限和ACLs (Access Control Lists)一起使用，为数据提供进一步的安全性。
Hive连接器 概述 Hive连接器支持查询存储在Hive数据仓库中的数据。Hive由三个部分组成： 存储在HDFS或Amazon S3中的不同格式的数据文件。 有关数据文件如何映射到模式和表的元数据。该元数据存储在MySQL等数据库中，通过Hive元存储服务访问。 一种称为HiveQL的查询语言。这种查询语言在分布式计算框架（如MapReduce或Tez）上执行。 openLooKeng只使用前两个部分：数据和元数据。不使用HiveQL或Hive的任何部分执行环境。 支持的文件类型 Hive连接器支持以下文件类型： ORC Parquet Avro RCFile SequenceFile JSON 文本 为了在使用Hive 3.x时能够对Avro表和CSV文件实现一级支持，需要在Hive元存储配置文件hive-site.xml中添加如下属性定义： <property> <!-- https://community.hortonworks.com/content/supportkb/247055/errorjavalangunsupportedoperationexception-storage.html --> <name>metastore.storage.schema.reader.impl</name> <value>org.apache.hadoop.hive.metastore.SerDeStorageSchemaReader</value> </property> 配置 Hive连接器支持Apache Hadoop 2.x及其衍生发行版，包括Cloudera CDH 5和Hortonworks Data Platform (HDP)。 用以下内容创建etc/catalog/hive.properties，以将hive-hadoop2连接器挂载为hive目录，将example.net:9083替换为Hive元存储Thrift服务的正确主机和端口： connector.name=hive-hadoop2 hive.metastore.uri=thrift://example.net:9083 多Hive集群 可以根据需要创建任意多的目录，因此，如果有额外的Hive集群，只需添加另一个不同的名称的属性文件到etc/catalog中（确保它以.properties结尾）。例如，如果将属性文件命名为sales.properties，openLooKeng将使用配置的连接器创建一个名为sales的目录。 HDFS配置 对于基本设置，openLooKeng自动配置HDFS客户端，不需要任何配置文件。在某些情况下，例如使用联邦HDFS或NameNode高可用性时，需要指定额外的HDFS客户端选项，以便访问HDFS集群。要指定选项，添加hive.config.resources属性来引用HDFS配置文件： hive.config.resources=/etc/hadoop/conf/core-site.xml,/etc/hadoop/conf/hdfs-site.xml 如果设置需要，只指定附加的配置文件。同时建议减少配置文件，使其具有所需的最小属性集，因为附加属性可能导致问题。 所有openLooKeng节点上必须存在配置文件。如果你正在引用现有的Hadoop配置文件，请确保将其复制到任何没有运行Hadoop的openLooKeng节点。 HDFS用户名和权限 在openLooKeng中对Hive表执行任何CREATE TABLE或CREATE TABLE AS语句之前，需要确保openLooKeng访问HDFS的用户能够访问Hive的仓库目录。Hive的仓库目录由hive-site.xml中的配置变量hive.metastore.warehouse.dir指定，默认值为/user/hive/warehouse。 在不使用带HDFS的Kerberos时，openLooKeng会使用openLooKeng进程的操作系统用户来访问HDFS。例如，如果openLooKeng作为nobody运行，则openLooKeng将作为nobody访问HDFS。可以通过在openLooKeng JVM配置中设置HADOOP_USER_NAME系统属性来覆盖此用户名，用适当的用户名替换hdfs_user： -DHADOOP_USER_NAME=hdfs_user hive用户通常可行，因为Hive通常随hive用户启动，并且该用户可以访问Hive仓库。 无论何时修改openLooKeng访问HDFS的用户时，请移除HDFS上的/tmp/openlookeng-*，/tmp/presto-*，/tmp/hetu-*，因为新用户可能无法访问现有的临时目录。 访问Kerberos身份验证保护的Hadoop集群 HDFS和Hive元存储都支持Kerberos认证。但是，目前还不支持通过票据缓存进行Kerberos身份验证。 Hive连接器安全需要的属性在Hive配置属性表中列出。有关Hive连接器中安全选项的更详细讨论，请参阅Hive安全配置部分。 Hive配置属性 属性名称 说明 默认值 hive.
Hudi连接器 版本说明 目前Hudi只支持0.7.0版本。 Hudi介绍 Apache Hudi是一个快速迭代的数据湖存储系统，可以帮助企业构建和管理PB级数据湖。它提供在DFS上存储超大规模数据集，同时使得流式处理如果批处理一样，该实现主要是通过如下两个原语实现。 Update/Delete记录: Hudi支持更新/删除记录，使用文件/记录级别索引，同时对写操作提供事务保证。查询可获取最新提交的快照来产生结果。（在文件中随机存取记录，记录的地址即为文件/记录索引） Change Streams: Hudi也支持增量获取表中所有更新/插入/删除的记录，从指定时间点开始进行增量查询。 支持的表格类型和查询类型 Hudi支持如下两种类型表 Copy On Write (COW): 使用列式存储格式（如parquet）存储数据，在写入时同步更新版本/重写数据。 Merge On Read (MOR): 使用列式存储格式（如parquet）+ 行存（如Avro）存储数据。更新被增量写入delta文件，后续会进行同步/异步压缩产生新的列式文件版本。 Hudi支持如下查询类型 快照查询: 查询给定commit/compaction的表的最新快照。对于Merge-On-Read表，通过合并基础文件和增量文件来提供近实时数据（分钟级）；对于Copy-On-Write表，对现有Parquet表提供了一个可插拔替换，同时提供了upsert/delete和其他特性。 读优化查询: 查询给定commit/compaction的表的最新快照。只提供最新版本的基础/列式数据文件，并可保证与非Hudi表相同的列式查询性能。 配置 通常情况下，我们会从外部数据源汲取数据并写入到DFS文件存储系统中，例如HDFS上，然后我们会通过Hudi提供的数据同步工具，将Hudi数据从HDFS上同步到Hive表中，此时Hudi表将作为Hive的外表存储，然后我们可以通过连接Hive Connector来访问Hudi表进行数据查询。Hudi表的生成以及同步到Hive表中的步骤请参考Hudi官方样例。 首先，在开始使用Hudi连接器之前，应该先完成以下步骤： 用于连接Hudi的JDBC连接详情 要配置Hudi连接器（即Hive 连接器），用以下内容创建etc/catalog/hive.properties，以将hive-hadoop2连接器挂载为hive目录，将example.net:9083替换为Hive元存储Thrift服务的正确主机和端口： connector.name=hive-hadoop2 hive.metastore.uri=thrift://example.net:9083 添加Hudi驱动 （Hudi版本为0.7.0） # 下载Hudi源码并编译 cd /opt wget https://github.com/apache/hudi/releases/tag/release-0.7.0 tar -zxvf hudi-release-0.7.0.tar.gz cd hudi-release-0.7.0 mvn package -DskipTests 编译完成后，进入目录/opt/hudi-release-0.7.0/packaging/hudi-presto-bundle/target/，得到文件hudi-presto-bundle-0.7.0.jar，我们需要将其放到openLooKeng插件文件夹中。例如，openLooKeng插件包文件夹为 /opt/hetu-server-1.3.0-SNAPSHOT/plugin，则拷贝命令如下：cp /opt/hudi-presto-bundle-0.7.0.jar /opt/hetu-server-1.3.0-SNAPSHOT/plugin/hive-hadoop2。此时，为防止读取Hudi表时版本依赖的冲突，需要将当前目录下的hudi-common-0.8.0.jar, hudi-hadoop-mr-0.8.0.jar删除，还需要在当前目录下放入jackson-mapper-asl-1.9.13.jar和jackson-core-asl-1.9.13.jar文件（这两个jar包可以从Hudi源码编译后的/opt/hudi-release-0.7.0/hudi-cli/target/lib路径下找到）。 # 复制Hudi驱动包 cp hudi-presto-bundle-0.7.0.jar /opt/hetu-server-1.3.0-SNAPSHOT/plugin/hive-hadoop2 # 删除hudi-common-0.
Iceberg连接器 概述 openLooKeng Iceberg 是一种用于大型分析数据集的开放表式。Iceberg 连接器允许查询存储在以 Iceberg 格式编写的文件中的数据。 Iceberg 数据文件可以存储为 Parquet、ORC 格式，由format表定义中的属性决定。该表format默认为ORC。 要求 要使用 Iceberg，您需要： 从openLooKeng 协调节点和工作节点到分布式对象存储的网络访问。 访问 Hive 元存储服务 (HMS) 。 从 openLooKeng 协调器到 HMS 的网络访问。使用 Thrift 协议的 Hive Metastore 访问默认使用端口 9083。 Hive元存储目录 Hive 元存储目录是默认实现。使用它时，Iceberg 连接器支持与 Hive 连接器相同的元存储配置属性。至少，hive.metastore.uri必须配置。 connector.name=iceberg hive.metastore.uri=thrift://localhost:9083 一般配置 这些配置属性与使用的目录实现无关。 Iceberg 通用配置属性 用以下内容创建etc/catalog/iceberg.properties，请把localhost:9083替换为Hive元存储Thrift服务的正确主机和端口： 属性名 属性值 是否必填 描述 connector.name iceberg 是 连接名 hive.metastore.uri thrift://localhost:9083 是 hive连接地址 iceberg.
JMX连接器 JMX连接器提供从openLooKeng集群中的所有节点查询JMX信息的能力。这对于检视或调试非常有用。Java管理扩展（JMX）提供了有关Java虚拟机和其中运行的所有软件的信息。openLooKeng本身就是通过JMX大量使用的工具。 还可以配置该连接器以便定期转储所选的JMX信息，并将其存储在内存中供以后访问。 配置 要配置JMX连接器，创建一个具有以下内容的目录属性文件etc/catalog/jmx.properties： connector.name=jmx 要启用定期转储，请定义以下属性： connector.name=jmx jmx.dump-tables=java.lang:type=Runtime,presto.execution.scheduler:name=NodeScheduler jmx.dump-period=10s jmx.max-entries=86400 dump-tables是逗号分隔的托管Bean (MBean)列表。它指定了每个dump-period采样哪些MBean并存储在内存中。历史记录将限制为max-entries条条目的大小。dump-period和max-entries相应的默认值为10s和86400。 MBean名称中的逗号需要按如下方式进行转义： connector.name=jmx jmx.dump-tables=presto.memory:type=memorypool\\,name=general,\ presto.memory:type=memorypool\\,name=system,\ presto.memory:type=memorypool\\,name=reserved 查询JMX JMX连接器提供了两种模式。 第一种是current，包含openLooKeng集群中每个节点的每个MBean。通过运行SHOW TABLES，可以看到所有可用的MBean： SHOW TABLES FROM jmx.current; MBean名称映射到非标准表名，并且在查询中引用时必须用双引号引起来。例如，以下查询显示了每个节点的JVM版本： SELECT node, vmname, vmversion FROM jmx.current."java.lang:type=runtime"; node | vmname | vmversion --------------------------------------+-----------------------------------+----------- ddc4df17-0b8e-4843-bb14-1b8af1a7451a | Java HotSpot(TM) 64-Bit Server VM | 24.60-b09 (1 row) 以下查询显示了每个节点的打开和最大文件描述符计数： SELECT openfiledescriptorcount, maxfiledescriptorcount FROM jmx.current."java.lang:type=operatingsystem"; openfiledescriptorcount | maxfiledescriptorcount -------------------------+------------------------ 329 | 10240 (1 row) 通配符*可以与current模式中的表名一起使用。这允许在单个查询中匹配多个MBean对象。以下查询返回每个节点上不同openLooKeng内存池的信息： SELECT freebytes, node, object_name FROM jmx.
Kafka连接器教程 介绍 适用于openLooKeng的Kafka连接器允许使用openLooKeng从Apache Kafka访问实时主题数据。本教程演示如何设置主题以及如何创建支持openLooKeng表的主题描述文件。 安装 本教程假定用户熟悉openLooKeng且本地安装有可用的openLooKeng（见手动部署openLooKeng）。教程将专注于设置Apache Kafka并将其与openLooKeng集成。 步骤1：安装Apache Kafka 下载并解压Apache Kafka。 说明 本教程使用Apache Kafka 0.8.1进行了测试。教程应适用于任何0.8.x版本的Apache Kafka。 启动ZooKeeper和Kafka服务器： $ bin/zookeeper-server-start.sh config/zookeeper.properties [2013-04-22 15:01:37,495] INFO Reading configuration from: config/zookeeper.properties (org.apache.zookeeper.server.quorum.QuorumPeerConfig) ... $ bin/kafka-server-start.sh config/server.properties [2013-04-22 15:01:47,028] INFO Verifying properties (kafka.utils.VerifiableProperties) [2013-04-22 15:01:47,051] INFO Property socket.send.buffer.bytes is overridden to 1048576 (kafka.utils.VerifiableProperties) ... 这将在端口2181上启动ZooKeeper，在端口9092上启动Kafka。 步骤2：加载数据 从Maven Central下载tpch-kafka加载器： $ curl -o kafka-tpch https://repo1.maven.org/maven2/de/softwareforge/kafka_tpch_0811/1.0/kafka_tpch_0811-1.0.sh $ chmod 755 kafka-tpch 现在运行kafka-tpch程序，预加载带有tpch数据多个主题： $ ./kafka-tpch load --brokers localhost:9092 --prefix tpch. --tpch-type tiny 2014-07-28T17:17:07.
Kafka连接器 概述 此连接器允许在openLooKeng中将Apache Kafka主题用作表。每条消息在openLooKeng中显示为一行。 主题可以是实时的：当数据到达时，行将出现，当段被删除时，行将消失。如果在单个查询中多次访问同一个表（例如，执行自联接），这可能会导致奇怪的行为。 说明 Kafka代理最低支持版本为0.10.0。 配置 要配置Kafka连接器，创建具有以下内容的目录属性文件etc/catalog/kafka.properties，并适当替换以下属性： connector.name=kafka kafka.table-names=table1,table2 kafka.nodes=host1:port,host2:port 多Kafka集群 可以根据需要创建任意多的目录，因此，如果有额外的Kafka集群，只需添加另一个不同的名称的属性文件到etc/catalog中（确保它以.properties结尾）。例如，如果将属性文件命名为sales.properties，openLooKeng将使用配置的连接器创建一个名为sales的目录。 配置属性 配置属性包括： 属性名称 说明 kafka.table-names 目录提供的所有表列表 kafka.default-schema 表的默认模式名 kafka.nodes Kafka集群节点列表 kafka.connect-timeout 连接Kafka集群超时 kafka.buffer-size Kafka读缓冲区大小 kafka.table-description-dir 包含主题描述文件的目录 kafka.hide-internal-columns 控制内部列是否是表模式的一部分 kerberos.on 是否开启Kerberos认证 user.password.auth.on 是否开启kafka用户密码认证 sasl.jaas.config 认证相关信息 java.security.krb5.conf krb5.conf文件路径 group.id kafka的groupID security.
Kylin连接器 Kylin连接器允许在外部Kylin数据库中查询表。这可用于在Kylin和Hive等不同系统之间或在两个不同的Kylin实例之间联接数据。 配置 要配置Kylin连接器，在etc/catalog中创建一个目录属性文件，例如Kylin.properties，将Kylin连接器挂载为kylin目录。使用以下内容创建文件，并根据设置替换连接属性： connector.name=kylin connection-url=jdbc:kylin://example.net/project connection-user=root connection-password=secret connector-planoptimizer-rule-blacklist=io.prestosql.sql.planner.iterative.rule.SingleDistinctAggregationToGroupBy 其中connector-planoptimizer-rule-blacklist属性是对kylin特殊配置的，默认值就为io.prestosql.sql.planner.iterative.rule.SingleDistinctAggregationToGroupBy 多个Kylin服务器 可以根据需要创建任意多的目录，因此，如果有额外的Kylin服务器，只需添加另一个不同名称的属性文件到etc/catalog中（确保它以.properties结尾）。例如，如果将属性文件命名为sales.properties，openLooKeng将使用配置的连接器创建一个名为sales的目录。 查询Kylin 可以访问web数据库中clicks的表： SELECT * FROM kylin.web.clicks; 如果对目录属性文件使用不同的名称，请使用该目录名称，而不要使用上述示例中的kylin。 Kylin连接器限制 暂不支持以下SQL语句： DELETE、../sql/update.md)、../sql/delete.html)、GRANT、REVOKE、SHOW GRANTS、SHOW ROLES、SHOW ROLE GRANTS
本地文件连接器 本地文件连接器允许查询每个工作节点的本地文件系统上存储的数据。 配置 要配置本地文件连接器，需在etc/catalog目录下新建一个例如名为localfile.properties的文件，内容如下： connector.name=localfile 配置属性 属性名称 说明 presto-logs.http-request-log.location 写入HTTP请求日志的目录或文件 presto-logs.http-request-log.pattern 如果日志位置是一个目录，这个glob将用于匹配目录中的文件名。 本地文件连接器模式和表 本地文件连接器提供了一个名为logs的模式。通过执行SHOW TABLES，可以看到所有可用的表： SHOW TABLES FROM localfile.logs; http_request_log 该表包含来自集群中每个节点的HTTP请求日志。
MariaDB连接器 MariaDB连接器允许在外部MariaDB数据库中查询和创建表。这可用于在MySQL和MariaDB等不同系统之间或在两个不同的MariaDB实例之间联接数据。 配置 要配置MariaDB连接器，在openLooKeng的安装目录中etc/catalog中创建一个目录属性文件，例如maria.properties，将MariaDB连接器挂载为maria目录。使用以下内容创建文件，并根据设置替换连接属性： connector.name=maria connection-url=jdbc:mariadb://部署了MairaDB的ip:MariaDB服务端口(默认3306) connection-user=您的数据源用户 connection-password=您的数据源密码 是否开启查询下推功能 如果要启用MariaDB连接器的连接器下推功能，不需要做任何操作，MariaDB连接器的下推功能默认是打开的。但也可以按如下设置： #true表示打开下推，false表示关闭。 jdbc.pushdown-enabled=true 下推模式选择 MariaDB连接器的下推模式默认是部分下推的，如果要启用MariaDB连接器的全部下推功能，可以按如下设置： #FULL_PUSHDOWN，表示全部下推；BASE_PUSHDOWN，表示部分下推，其中部分下推是指filter/aggregation/limit/topN/project这些可以下推。 jdbc.pushdown-module=FULL_PUSHDOWN 外部函数注册 MariaDB连接器支持注册外部函数。 配置支持下推的外部函数注册命名空间catalog.schema。 例如在etc/catalog/maria.properties中配置： jdbc.pushdown.remotenamespace=mariafun.default 外部函数下推 将外部函数下推到MariaDB数据源执行。 配置支持下推的外部函数注册命名空间catalog.schema。 例如在etc/catalog/maria.properties中配置： jdbc.pushdown.remotenamespace=mariafun.default 可以声明自己支持多个函数命名空间中的函数，在jdbc.pushdown.remotenamespace配置项中使用'|'分割既可。例如： jdbc.pushdown.remotenamespace=mariafun1.default|mariafun2.default|mariafun3.default #表示当前Connector实例同时支持mysqlfun1.default、mysqlfun2.default、mysqlfun3.default三个函数命名空间最终的函数下推到当前连接的数据源中执行。 多个MariaDB服务器 可以根据需要创建任意多的目录，因此，如果有额外的MariaDB服务器，只需添加另一个不同名称的属性文件到etc/catalog中（确保它以.properties结尾）。例如，如果将属性文件命名为sales.properties，openLooKeng将使用配置的连接器创建一个名为sales的目录。 查询MySQL MariaDB连接器为每个MariaDB数据库提供一个模式。可通过执行SHOW SCHEMAS来查看可用MariaDB数据库： -- 我们的catalog名称为maria SHOW SCHEMAS FROM maria; 如果有一个名为test的MySQL数据库，可以通过执行SHOW TABLES查看数据库中的表： SHOW TABLES FROM maria.test; 可以使用以下方法之一查看test数据库中user表中的列的列表： DESCRIBE maria.test.user; SHOW COLUMNS FROM maria.test.user; 最后，可以访问test数据库中user的表： SELECT * FROM maria.test.user; 如果对目录属性文件使用不同的名称，请使用该目录名称，而不要使用上述示例中的maria。 MariaDB连接器限制 暂不支持以下SQL语句： DELETE、GRANT、REVOKE、SHOW GRANTS、SHOW ROLES、SHOW ROLE GRANTS
内存连接器 内存连接器将所有数据和元数据存储在工作节点上的内存中来获得更好的性能。 同时元数据和数据也被后台写入磁盘并在需要时自动读取。 配置 内存连接器配置 配置内存连接器时，创建或修改具有以下内容的目录属性文件etc/catalog/memory.properties： connector.name=memory memory.max-data-per-node=200GB memory.spill-path=/opt/hetu/data/spill 其他必要的配置 本节将介绍使用内存连接器所需的其他配置。 更多信息请参考Hetu Metastore和State Store的文档。 单个节点设置 本节将给出单节点集群上内存连接器的示例配置。 创建文件 etc/catalog/memory.properties并填入以下配置: connector.name=memory memory.max-data-per-node=200GB memory.spill-path=/opt/hetu/data/spill 创建文件 etc/hetu-metastore.properties 并填入以下配置: hetu.metastore.type=hetufilesystem hetu.metastore.hetufilesystem.profile-name=default hetu.metastore.hetufilesystem.path=/tmp/hetu/metastore hetu.metastore.cache.type=local 多节点设置 本节将为具有多个节点的集群提供内存连接器的示例配置。 创建文件 etc/catalog/memory.properties 并填入以下配置: connector.name=memory memory.max-data-per-node=200GB memory.spill-path=/opt/hetu/data/spill 在 etc/config.properties 文件中加入以下代码来启用 State Store: State Store 允许 Memory Connector 自动清理删除的表，否则只有在创建另一个表时才会清理表。 hetu.embedded-state-store.enabled=true 创建文件 etc/state-store.properties 并填入以下配置: state-store.type=hazelcast state-store.name=test state-store.cluster=test-cluster hazelcast.discovery.mode=tcp-ip hazelcast.discovery.port=7980 # 每个服务器的ip地址和hazelcast端口应该被声明在这里。 # 格式：`hazelcast.
MongoDB连接器 MongoDB连接器允许将MongoDB集合作为openLooKeng中的表使用。 注意 支持MongoDB 2.6+，但建议使用3.0或更高版本。 配置 要配置MongoDB连接器，参考以下内容创建目录属性文件etc/catalog/mongodb.properties，并根据需要替换这些属性： connector.name=mongodb mongodb.seeds=host1,host:port 多个MongoDB集群 可以根据需要创建多个目录，因此，如果有额外的MongoDB集群，只需添加另一个不同的名称的属性文件到etc/catalog中（确保它以.properties结尾）。例如，如果将属性文件命名为sales.properties，openLooKeng将使用配置的连接器创建一个名为sales的目录。 配置属性 支持的配置属性： 属性名称 说明 mongodb.seeds 所有mongod服务器的列表 mongodb.schema-collection 一个包含schema信息的集合 mongodb.case-insensitive-name-matching 不区分大小写匹配数据库和集合名称 mongodb.credentials 认证列表 mongodb.min-connections-per-host 每个主机的最小连接池大小 mongodb.connections-per-host 每个主机的连接池的最大大小 mongodb.max-wait-time 最大等待时间 mongodb.max-connection-idle-time 池化连接的最大空闲时间 mongodb.connection-timeout 通信连接超时 mongodb.socket-timeout 通信超时 mongodb.socket-keep-alive 是否在每个通信上使能keep-alive mongodb.ssl.enabled 使用TLS/SSL连接到mongod/mongos mongodb.
mpp连接器 本方案旨在通过GDS高速协议来提高openLookeng引擎读取GaussDB的性能。 目前对于GaussDB数据库的数据查询方式是通过JDBC Connector来实现的，和大部分关系型数据库连接类似。由于传统的MySQL等数据库存储的数据量小，因此通过JDBC方式来获取数据无可厚非。但是由于GaussDB是一种MPP类的分布式数据库，存储数据量大，且主要用于OLAP场景的分析，导致通过原生JDBC方式拉取数据的方式变得低效，因为它是一种单进单出的模式。 后来，社区也针对这种情况进行了基于JDBC的优化，例如增加了下推，在引擎端增加了多split并发，但是依然无法避免数据源端的单并发，性能瓶颈依然无法得到完全的解决，而且多并发还会带来多连接的情况，对数据库集群造成一定的压力。 本方案将会通过解决数据源端和引擎端并发问题来提高引擎查询的效率。 mpp连接器设计思路 本方案将mpp类数据库的查询转换成对hive外表的查询，即将mpp类数据库的表数据快速导出到外部的分布式文件系统或分布式缓存，然后通过挂hive外表的方式通过hive connector来进行查询。本方案的主要权衡点在于导出数据的效率和mpp数据库通过单CN节点对外输出数据的效率的比较。随着查询数据量的递增，本方案的效率提高也会越来越高。 更详细的内容见社区分享：https://mp.weixin.qq.com/s/Q-t592UerICHNXI63rhtPg 配置 要配置mpp连接器，在etc/catalog中创建一个目录属性文件，例如mpp.properties，使用以下内容创建文件，并根据设置替换连接属性： 本方案本质上是将查询gaussdb数据库转换成查询hive，因此以下配置均基于此原理。 connector.name=mpp # 配置用来做最后查询的hive仓库 hive.metastore.uri=thrift://localhost:9083 etl-reuse=false #是否复用本次导数结果 #GDS baseinfo #gds进程，基于postgres的fdw机制实现的一个快速导数进程，gaussdb官方插件 gds-list=gsfs://localhost:port1|base_path #gds的ip和端口，以及该进程启动时候的basepath，多个gds进程可以通过逗号分隔 aux-url=alluxio://localhost:19998 #alluxio的ip和端口 base-aux=/gdsdata/ #alluxio中用来为gds导出数据服务的路径，可自定义 #hive info # 用来进行创建外表等操作的hive仓库连接配置 hive-user=username hive-passwd=password hive-db=xxx_db hive-url=jdbc:hive2://localhost:10000/ # hive template ## 进行hive外表创建的相关SQL模板，一般无需更改 hsql-drop=drop table if exists ${table_name} hsql-create=CREATE EXTERNAL TABLE ${table_name} ( ${schema_info} ) COMMENT 'gds external table' ROW FORMAT DELIMITED FIELDS TERMINATED BY ',' LINES TERMINATED BY '\n' LOCATION '${pipe_to_aux_base_path}' # gsDB connection info # 要查询的GaussDB数据库相关连接信息 gs-driver=org.
MySQL连接器 MySQL连接器允许在外部MySQL数据库中查询和创建表。这可用于在MySQL和Hive等不同系统之间或在两个不同的MySQL实例之间联接数据。 配置 要配置MySQL连接器，在etc/catalog中创建一个目录属性文件，例如mysql.properties，将MySQL连接器挂载为mysql目录。使用以下内容创建文件，并根据设置替换连接属性： connector.name=mysql connection-url=jdbc:mysql://example.net:3306 connection-user=root connection-password=secret 是否开启查询下推功能 如果要启用mysql连接器的连接器下推功能，不需要做任何操作，mysql连接器的下推功能默认是打开的。但也可以按如下设置： jdbc.pushdown-enabled=true #true表示打开下推，false表示关闭。 下推模式选择 mysql连接器的下推模式默认是部分下推的，如果要启用mysql连接器的全部下推功能，可以按如下设置： jdbc.pushdown-module=FULL_PUSHDOWN #FULL_PUSHDOWN，表示全部下推；BASE_PUSHDOWN，表示部分下推，其中部分下推是指filter/aggregation/limit/topN/project这些可以下推。 外部函数注册 MySQL连接器支持注册外部函数。 配置支持下推的外部函数注册命名空间catalog.schema。 例如在etc/catalog/mysql.properties中配置： jdbc.pushdown.remotenamespace=mysqlfun.default 外部函数下推 将外部函数下推到MySQL数据源执行。 配置支持下推的外部函数注册命名空间catalog.schema。 例如在etc/catalog/mysql.properties中配置： jdbc.pushdown.remotenamespace=mysqlfun.default 可以声明自己支持多个函数命名空间中的函数，在jdbc.pushdown.remotenamespace配置项中使用'|'分割既可。例如： jdbc.pushdown.remotenamespace=mysqlfun1.default|mysqlfun2.default|mysqlfun3.default #表示当前Connector实例同时支持mysqlfun1.default、mysqlfun2.default、mysqlfun3.default三个函数命名空间最终的函数下推到当前连接的数据源中执行。 多个MySQL服务器 可以根据需要创建任意多的目录，因此，如果有额外的MySQL服务器，只需添加另一个不同名称的属性文件到etc/catalog中（确保它以.properties结尾）。例如，如果将属性文件命名为sales.properties，openLooKeng将使用配置的连接器创建一个名为sales的目录。 查询MySQL MySQL连接器为每个MySQL数据库提供一个模式。可通过执行SHOW SCHEMAS来查看可用MySQL数据库： SHOW SCHEMAS FROM mysql; 如果有一个名为web的MySQL数据库，可以通过执行SHOW TABLES查看数据库中的表： SHOW TABLES FROM mysql.web; 可以使用以下方法之一查看web数据库中clicks表中的列的列表： DESCRIBE mysql.web.clicks; SHOW COLUMNS FROM mysql.web.clicks; 最后，可以访问web数据库中clicks的表： SELECT * FROM mysql.web.clicks; 如果对目录属性文件使用不同的名称，请使用该目录名称，而不要使用上述示例中的mysql。 MySQL连接器限制 暂不支持以下SQL语句： DELETE、GRANT、REVOKE、SHOW GRANTS、SHOW ROLES、SHOW ROLE GRANTS
OmniData连接器 概述 OmniData连接器支持查询存储在远端Hive数据仓库中的数据。它通过将openLooKeng的算子下推到存储节点以实现近数据计算，从而降低网络传输数据量、提升计算性能。 更多信息请见：OmniData和OmniData connector。 支持的文件类型 OmniData连接器支持以下文件类型： ORC Parquet Text 配置 用以下内容创建etc/catalog/omnidata.properties，并将example.net:9083替换为Hive元存储Thrift服务的主机和端口： connector.name=omnidata-openlookeng hive.metastore.uri=thrift://example.net:9083 HDFS配置 通常，openLooKeng会自动配置HDFS客户端，不需要任何配置文件。在某些情况下，例如使用联邦HDFS或NameNode高可用性时，需要指定额外的HDFS客户端选项，以便访问HDFS集群。可通过添加hive.config.resources属性来引用HDFS配置文件： hive.config.resources=/etc/hadoop/conf/core-site.xml,/etc/hadoop/conf/hdfs-site.xml 所有openLooKeng节点上都必须存在这些配置文件。如果你正在引用现有的Hadoop配置文件，请确保将其复制到所有没有运行Hadoop的openLooKeng节点。 OmniData配置属性 属性名称 说明 默认值 hive.metastore Hive元存储类型 thrift hive.config.resources 以逗号分隔的可选HDFS配置文件列表。这些文件必须存在于运行openLooKeng的机器上。该属性仅在访问HDFS绝对必要的情况下指定。示例：/etc/hdfs-site.xml hive.omnidata-enabled 允许下推算子到存储侧执行。如果被禁用，所有算子将不会被下推。 true hive.min-offload-row-number 若数据表的行数小于该阈值，则该数据表的所有算子将不会被下推。 500 hive.filter-offload-enabled 允许下推filter算子到存储侧执行。如果被禁用，filter算子将不会被下推。 true hive.filter-offload-factor filter算子被下推时的数据选择率阈值。只有当算子的选择率小于该阈值，该算子它才会被下推。 0.25 hive.aggregator-offload-enabled 允许下推aggregator算子到存储侧执行。如果被禁用，aggregator算子将不会被下推。 true hive.aggregator-offload-factor aggregator算子被下推时的数据聚合率阈值。只有当算子的聚合率小于该阈值，该算子才会被下推。 0.25 更多的配置，请参阅Hive配置属性章节。
openGauss连接器 openGauss连接器允许在外部openGauss数据库中查询和创建表。这可用于在openGauss和Hive等不同系统之间或在两个不同的openGauss实例之间联接数据。 配置 要配置openGauss连接器，在etc/catalog中创建一个目录属性文件，例如opengauss.properties，将openGauss连接器挂载为opengauss目录。使用以下内容创建文件，并根据设置替换连接属性： connector.name=opengauss connection-url=jdbc:postgresql://example.net:15400/database connection-user=root connection-password=secret 多个openGauss数据库或服务器 openGauss连接器只能访问openGauss服务器中的单个数据库。因此，如果有多个openGauss数据库，或者想要连接到多个openGauss服务器，则必须配置多个openGauss连接器实例。 要添加另一个目录，只需添加另一个属性文件到具有不同名称的etc/catalog中（确保它以.properties结尾）。例如，如果将属性文件命名为sales.properties，openLooKeng将使用配置的连接器创建一个名为sales的目录。 查询openGauss openGauss连接器为每个openGauss模式提供一个模式。可通过执行SHOW SCHEMAS来查看可用的openGauss模式： SHOW SCHEMAS FROM opengauss; 如果有一个名为public的openGauss模式，那么可以通过执行SHOW TABLES来查看这个模式中的表： SHOW TABLES FROM opengauss.public; 可以使用以下方法之一查看数据库public中hetutb表中的列的列表： DESCRIBE opengauss.public.hetutb; SHOW COLUMNS FROM opengauss.public.hetutb; 最后，可以访问public模式中的hetutb表： SELECT * FROM opengauss.public.hetutb; 如果对目录属性文件使用不同的名称，请使用该目录名称，而不要使用上述示例中的opengauss。 openGauss Update/Delete 支持 使用openGauss连接器创建表 示例： CREATE TABLE opengauss_table ( id int, name varchar(255)); 对表执行INSERT 示例： INSERT INTO opengauss_table VALUES (1, 'Jack'), (2, 'Bob'); 对表执行UPDATE 示例： UPDATE opengauss_table SET name='Tim' WHERE id=1; 上述示例将列id中值为1所在行的列name的值更新为Tim。
Oracle连接器 概述 Oracle连接器允许在外部Oracle数据库中查询和创建表。这可用于在Oracle和Hive等不同系统之间或在两个不同的Oracle实例之间联接数据。 配置 基础配置 首先，在开始使用oracle连接器之前，应该先完成以下步骤： 用于连接Oracle的JDBC连接详情 应该以常规openLooKeng连接器配置编写（例如名为oracle的openLooKeng目录使用oracle.properties）。文件应包含以下内容，并根据设置替换连接属性： 基本属性设置： connector.name=oracle connection-url=jdbc:oracle:thin:@主机:端口/ORCLCDB connection-user=用户名 connection-password=密码 添加Oracle驱动 Oracle JDBC驱动不在普通存储库中提供，如果您是oracle数据库的用户，您可以选择前往Oracle官方网站，在确保遵守Oracle JDBC驱动所适用的license的条件下，下载和安装Oracle JDBC驱动到存储库中。Oracle JDBC驱动（ojdbcX.jar X为数字，根据Oracle的版本不同而不同）可能会作为Oracle客户端安装的一部分进行安装，或者从Oracle办公网站下载。获取了Oracle JDBC驱动后，您可以将jdbc jar文件部署到协调节点和工作节点上的openLooKeng插件文件夹中。例如，jdbc驱动文件为ojdbcX.jar，openLooKeng插件包文件夹为 /usr/lib/presto/lib/plugin，则拷贝命令如下： cp ojdbcX.jar /usr/lib/presto/lib/plugin/oracle。重启协调节点和工作节点进程，oracle连接器即可正常工作。 是否开启查询下推功能 如果要启用oracle连接器的连接器下推功能，不需要做任何操作，oracle连接器的下推功能默认是打开的。但也可以按如下设置： jdbc.pushdown-enabled=true #true表示打开下推，false表示关闭。 下推模式选择。 如果要启用oracle连接器的全部下推功能，不需要做任何操作，oracle连接器的下推模式默认是全部下推的。但也可以按如下设置： jdbc.pushdown-module=FULL_PUSHDOWN #FULL_PUSHDOWN，表示全部下推；BASE_PUSHDOWN，表示部分下推，其中部分下推是指filter/aggregation/limit/topN/project这些可以下推。 多套Oracle数据库或服务器 如果要连接到多个Oracle数据库，请将Oracle插件的另一个实例配置为一个单独的目录。如需添加其他Oracle目录，请在 ../conf/catalog 下添加不同名称的另一属性文件（注意结尾为 .properties ）。例如，在 ../conf/catalog 目录下新增一个名称为 oracle2.properties 的文件，则新增一个名称为oracle2的连接器。 通过openLooKeng查询Oracle 对于名为oracle的oracle连接器，每个Oracle数据库的用户都可以通过oracle连接器获取其可用的模式，命令为SHOW SCHEMAS： SHOW SCHEMAS FROM oracle; 如果已经拥有了可用模式，可以通过SHOW TABLES命令查看名为data的Oracle数据库拥有的表： SHOW TABLES FROM oracle.data; 若要查看数据模式中名为hello的表中的列的列表，请使用以下命令中的一种： DESCRIBE oracle.data.hello; SHOW COLUMNS FROM oracle.
PostgreSQL连接器 PostgreSQL连接器允许在外部PostgreSQL数据库中查询和创建表。这可用于在PostgreSQL和Hive等不同系统之间或在两个不同的PostgreSQL实例之间联接数据。 配置 要配置PostgreSQL连接器，在etc/catalog中创建一个目录属性文件，例如postgresql.properties，将PostgreSQL连接器挂载为postgresql目录。使用以下内容创建文件，并根据设置替换连接属性： connector.name=postgresql connection-url=jdbc:postgresql://example.net:5432/database connection-user=root connection-password=secret 多个PostgreSQL数据库或服务器 PostgreSQL连接器只能访问PostgreSQL服务器中的单个数据库。因此，如果有多个PostgreSQL数据库，或者想要连接到多个PostgreSQL服务器，则必须配置多个PostgreSQL连接器实例。 要添加另一个目录，只需添加另一个属性文件到具有不同名称的etc/catalog中（确保它以.properties结尾）。例如，如果将属性文件命名为sales.properties，openLooKeng将使用配置的连接器创建一个名为sales的目录。 查询PostgreSQL PostgreSQL连接器为每个PostgreSQL模式提供一个模式。可通过执行SHOW SCHEMAS来查看可用的PostgreSQL模式： SHOW SCHEMAS FROM postgresql; 如果有一个名为web的PostgreSQL模式，那么可以通过执行SHOW TABLES来查看这个模式中的表： SHOW TABLES FROM postgresql.web; 可以使用以下方法之一查看数据库web中clicks表中的列的列表： DESCRIBE postgresql.web.clicks; SHOW COLUMNS FROM postgresql.web.clicks; 最后，可以访问web模式中的clicks表： SELECT * FROM postgresql.web.clicks; 如果对目录属性文件使用不同的名称，请使用该目录名称，而不要使用上述示例中的postgresql。 PostgreSQL Update/Delete 支持 使用PostgreSQL连接器创建表 示例： CREATE TABLE postgresql_table ( id int, name varchar(255)); 对表执行INSERT 示例： INSERT INTO postgresql_table VALUES (1, 'Jack'), (2, 'Bob'); 对表执行UPDATE 示例： UPDATE postgresql_table SET name='Tim' WHERE id=1; 上述示例将列id中值为1所在行的列name的值更新为Tim。
Redis 连接器 概述 此连接器允许在openlookeng中，将redis中一个kv键值对映射成表的一行数据 说明 kv键值对只能在Reids中映射为string或hash类型。keys可以存储为一个zset,然后keys可以被分割成多个片 支持 Redis 2.8.0 或更高版本 配置 要配置Redis连接器，创建具有以下内容的目录属性文件etc/catalog/redis.properties，并适当替换以下属性： connector.name=redis redis.table-names=schema1.table1,schema1.table2 redis.nodes=host1:port 多个 Redis Servers 可以根据需要创建任意多的目录，因此，如果有额外的redis server，只需添加另一个不同的名称的属性文件到etc/catalog中（确保它以.properties结尾）。例如，如果将属性文件命名为sales.properties，openLooKeng将使用配置的连接器创建一个名为sales的目录。 配置属性 配置属性包括： 属性名称 说明 redis.table-names catalog 提供的所有表的列表 redis.default-schema 表的默认schema名 (默认default) redis.nodes Redis server的节点列表 redis.connect-timeout 连接Redis server的超时时间 (ms) (默认 2000) redis.scan-count 每轮scan获得的key的数量 (默认 100) redis.key-prefix-schema-table Redis keys 是否有 schema-name:table-name的前缀 (默认 false) redis.key-delimiter 如果redis.
singleData连接器 singleData连接器为openGauss补充OLAP能力，增强数据分析竞争力。 singleData分为ShardingSphere和tidRange两种模式。 ShardingSphere模式 概述 Apache ShardingSphere是一款分布式数据库生态系统，它可以将任意数据库转换为分布式数据库，singleData连接器可以使用ShardingSphere对openGauss的数据进行分片，以提升数据分析效率。 要了解更多shardingsphere信息请见：ShardingSphere官方网站 配置 要配置ShardingSphere模式的singleData连接器，在etc/catalog中创建一个目录属性文件，例如shardingsphere.properties，使用以下内容创建文件，并替换相应的属性。 基本配置 connector.name=singledata singledata.mode=SHARDING_SPHERE shardingsphere.database-name=sharding_db shardingsphere.type=zookeeper shardingsphere.namespace=governance_ds shardingsphere.server-list=localhost:2181 属性说明 属性名称 属性说明 是否必要 shardingsphere.database-name 连接的shardingsphere database的名称 是 shardingsphere.type 注册中心持久化仓库类型，支持zookeeper和etcd，推荐zookeeper 是 shardingsphere.namespace 注册中心命名空间 是 shardingsphere.server-lists 注册中心连接地址 是 仓库类型为zookeeper的可选配置 属性名称 说明 默认值 shardingsphere.zookeeper.retry-interval-milliseconds 连接失败后重试间隔毫秒数 500 shardingsphere.
SQL Server连接器 SQL Server连接器允许在外部SQL Server数据库中查询和创建表。这可用于在SQL Server和Hive等不同系统之间或在两个不同的SQL Server实例之间联接数据。 配置 要配置SQL Server连接器，在etc/catalog中创建一个目录属性文件，例如sqlserver.properties，将SQL Server连接器挂载为sqlserver目录。使用以下内容创建文件，并根据设置替换连接属性： connector.name=sqlserver connection-url=jdbc:sqlserver://[serverName[\instanceName][:portNumber]] connection-user=root connection-password=secret 多个SQL Server数据库或服务器 SQL Server连接器只能访问SQL Server服务器中的单个数据库。因此，如果有多个SQL Server数据库，或者想要连接到多个SQL Server实例，则必须配置多个目录，每个实例一个。 要添加另一个目录，只需添加另一个属性文件到具有不同名称的etc/catalog中（确保它以.properties结尾）。例如，如果将属性文件命名为sales.properties，openLooKeng将使用配置的连接器创建一个名为sales的目录。 查询SQL Server服务器 SQL Server连接器提供对配置数据库中指定用户可见的所有模式的访问。对于以下示例，假设SQL Server目录为sqlserver。 可通过执行SHOW SCHEMAS来查看可用的模式： SHOW SCHEMAS FROM sqlserver; 如果有一个名为web的模式，那么可以通过执行SHOW TABLES来查看这个模式中的表： SHOW TABLES FROM sqlserver.web; 可以使用以下方法之一查看web数据库中clicks表中的列的列表： DESCRIBE sqlserver.web.clicks; SHOW COLUMNS FROM sqlserver.web.clicks; 最后，可以访问web模式中的clicks表： SELECT * FROM sqlserver.web.clicks; 如果对目录属性文件使用不同的名称，请使用该目录名称，而不要使用上述示例中的sqlserver。 SQL Server连接器限制 openLooKeng支持连接SQL Server 2016、SQL Server 2014、SQL Server 2012以及Azure SQL Database。 openLooKeng支持以下SQL Server数据类型。下表显示了SQL Server和openLooKeng数据类型之间的映射。
系统连接器 系统连接器提供当前运行的openLooKeng集群的信息和指标。这通过正常SQL查询实现。 配置 系统连接器无需配置：它通过一个名为system的目录自动可用。 使用系统连接器 列出可用的系统模式： SHOW SCHEMAS FROM system; 列出其中一个模式中的表： SHOW TABLES FROM system.runtime; 查询其中一个表： SELECT * FROM system.runtime.nodes; 杀掉正在运行的查询： CALL system.runtime.kill_query(query_id => '20151207_215727_00146_tx3nr', message => 'Using too many resources'); 系统连接器表 metadata.catalogs catalogs包含可用的目录列表。 metadata.schema_properties schema properties表包含可在创建新模式时设置的可用属性列表。 metadata.table_properties table properties表包含可在创建新表时设置的可用属性列表。 metadata.table_comments table comments表包含表注释的列表。 runtime.nodes nodes表包含openLooKeng集群中可见的节点列表及其状态。 runtime.queries queries表包含当前和最近运行的对openLooKeng集群查询的信息。从这个表中可以找到原始查询文本（SQL）、运行查询的用户的标识以及查询的性能信息，包括查询的排队和分析时间。 runtime.tasks tasks表包含有关openLooKeng查询中涉及的任务的信息，包括这些任务的执行位置以及每个任务处理的行数和字节数。 runtime.transactions transactions表包含当前打开的事务和相关元数据的列表。这包括例如创建时间、空闲时间、初始化参数和访问的目录等信息。 系统连接器流程 runtime.kill_query(query_id, message) 杀掉由query_id所标识的查询。查询失败消息中会包含指定的message。
Thrift连接器 Thrift连接器使得无需定制openLooKeng连接器实现就可以与外部存储系统集成。 为了与外部系统使用Thrift连接器，需要实现PrestoThriftService接口，见下文。接下来，将Thrift连接器配置为指向一组称为Thrift服务器的机器，这些机器实现该接口。作为接口实现的一部分，Thrift服务器将提供元数据、分片和数据。除非分片包含地址列表，否则连接器将从元数据调用或数据调用的可用实例中随机选择一个服务器与之通信。所有的请求都被假定为幂等的，并且可以在任何服务器之间自由地重试。 配置 要配置Thrift连接器，创建具有以下内容的目录属性文件etc/catalog/thrift.properties，并适当替换以下属性： connector.name=presto-thrift presto.thrift.client.addresses=host:port,host:port 多Thrift系统 可以根据需要创建任意多的目录，因此，如果有额外的Thrift系统供连接，只需添加另一个不同的名称的属性文件到etc/catalog中（确保它以.properties结尾）。 配置属性 配置属性包括： 属性名称 说明 presto.thrift.client.addresses Thrift服务器位置 presto-thrift.max-response-size Thrift服务器返回的最大数据量 presto-thrift.metadata-refresh-threads 元数据缓存刷新线程数 presto.thrift.client.max-retries Thrift请求失败最大重试次数 presto.thrift.client.max-backoff-delay 最大重试间隔 presto.thrift.client.min-backoff-delay 最小重试间隔 presto.thrift.client.max-retry-time Thrift请求所有尝试的最大时长 presto.thrift.client.backoff-scale-factor 指数后退比例系数 presto.thrift.client.connect-timeout 连接超时 presto.thrift.client.request-timeout 请求超时 presto.thrift.client.socks-proxy SOCKS代理地址 presto.thrift.client.max-frame-size Thrift原始响应最大长度 presto.thrift.client.transport Thrift传输类型（UNFRAMED、FRAMED、HEADER） presto.
TPCDS连接器 TPCDS连接器提供一组模式来支持TPC Benchmark™ DS (TPC-DS)。TPC-DS是一个数据库基准，用于衡量复杂决策支持数据库的性能。 此连接器还可以用于测试openLooKeng的功能和查询语法，而无需配置对外部数据源的访问。当查询TPCDS模式时，连接器使用确定性算法动态生成数据。 配置 要配置TPCDS连接器，创建一个具有以下内容的目录属性文件etc/catalog/tpcds.properties： connector.name=tpcds TPCDS模式 TPCDS连接器提供了几个模式： SHOW SCHEMAS FROM tpcds; Schema -------------------- information_schema sf1 sf10 sf100 sf1000 sf10000 sf100000 sf300 sf3000 sf30000 tiny (11 rows) 忽略标准模式information_schema，该模式每个目录中都存在，且不是由TPCDS连接器直接提供的。 每个TPCDS模式都提供相同的一组表。有些表在所有模式中都是相同的。特定模式中表的比例系数由模式名称确定。例如模式sf1对应比例系数1，模式sf300对应比例系数300。比例系数中的每一个单位都对应于1 GB的数据。例如，对于比例系数300，将生成总计300 GB。tiny模式是比例系数0.01的别名，该模式是用于测试的一个非常小的数据集。
TPCH连接器 TPCH连接器提供一组模式来支持TPC Benchmark™ H (TPC-H)。TPC-H是一个数据库基准，用于衡量高度复杂决策支持数据库的性能。 此连接器还可以用于测试openLooKeng的功能和查询语法，而无需配置对外部数据源的访问。当查询TPCH模式时，连接器使用确定性算法动态生成数据。 配置 要配置TPCH连接器，创建一个具有以下内容的目录属性文件etc/catalog/tpch.properties： connector.name=tpch TPCH模式 TPCH连接器提供了几个模式： SHOW SCHEMAS FROM tpch; Schema -------------------- information_schema sf1 sf100 sf1000 sf10000 sf100000 sf300 sf3000 sf30000 tiny (11 rows) 忽略标准模式information_schema，该模式每个目录中都存在，且不是由TPCH连接器直接提供的。 每个TPCH模式都提供相同的一组表。有些表在所有模式中都是相同的。其他表根据模式名确定的比例系数不同而不同。例如模式sf1对应比例系数1，模式sf300对应比例系数300。TPCH连接器为任何比例系数提供了无限数量的模式，而不仅仅是由SHOW SCHEMAS列出的几个常用模式。tiny模式是比例系数0.01的别名，该模式是用于测试的一个非常小的数据集。
VDM连接器 在一些场景中，需要在同一个会话或视图中管理或访问多个数据源，同时，用户不需要关心数据的分布和来源。虚拟数据市场（VDM）连接器旨在将该特性引入openLooKeng。 VDM连接器支持： 创建、更新和删除组合多个目录的视图 通过视图访问真实数据 通过视图管理用户权限 记录每个用户使用VDM视图的情况 配置 VDM使用openLooKeng元存储存储其数据库信息。信息可以存储在HDFS或关系数据库中，这取决于openLooKeng元存储的实现。 因此必须先配置VDM元数据的存储方式。 下面是使用RDBMS作为VDM元数据的示例，创建etc/hetu-metastore.properties： # the type of metastore storage hetu.metastore.type=jdbc # jdbc connection address of database hetu.metastore.db.url=jdbc:mysql://.... # the user name of the database hetu.metastore.db.user=root # the password of database hetu.metastore.db.password=123456 下面是使用HDFS作为元数据存储的实例，创建etc/hetu-metastore.properties： 路径配置白名单：["/tmp”, “/opt/hetu”, “/opt/openlookeng”, “/etc/hetu”, “/etc/openlookeng”, 工作目录] 注意：避免选择根目录；路径不能包含../；如果配置了node.data_dir,那么当前工作目录为node.data_dir的父目录； 如果没有配置，那么当前工作目录为openlookeng server的目录 # the type of metastore storage hetu.metastore.type=hetufilesystem # profile name of hetu file system hetu.
连接器 连接器是用于在 openLooKeng 中进行查询的所有数据的源。即使您的数据源没有可以支持它的基础表，只要将您的数据源与 openLooKeng 期望使用的 API 相适配，您也可以针对这些数据编写查询。 ConnectorFactory 连接器的实例由 ConnectorFactory 实例创建，当 openLooKeng 在插件上调用 getConnectorFactory() 时会创建该 ConnectorFactory 实例。 连接器工厂是负责创建 Connector 对象实例的简单接口，可返回以下服务的实例： ConnectorMetadata ConnectorSplitManager ConnectorHandleResolver ConnectorRecordSetProvider ConnectorMetadata 连接器元数据接口具有许多重要的方法，这些方法负责允许 openLooKeng 查看模式列表、表列表、列列表以及有关特定数据源的其他元数据。 该接口太大，无法在文档中列出，不过如果您有兴趣查看实现这些方法的策略，请查看 example-http 和 Cassandra 连接器。 如果您的基础数据源支持模式、表和列，则该接口应该很容易实现。 如果您试图修改某些非关系数据库的内容（与 Example HTTP 连接器执行的操作类似），则可能需要创造性地将数据源映射到 openLooKeng 的模式、表和列概念。 ConnectorSplitManager 分片管理器将表的数据分区成多个块，这些块由 openLooKeng 分发至工作节点进行处理。 例如，Hive 连接器列出每个 Hive 分区的文件，并为每个文件创建一个或多个分片。 对于没有已分区数据的数据源，此处一个比较好的策略是仅针对整个表返回单个分片。 这是 Example HTTP 连接器使用的策略。 ConnectorRecordSetProvider 在给定一个分片和一个列列表的情况下，记录集提供程序负责将数据提供给 openLooKeng 执行引擎。 记录集提供程序创建一个 RecordSet，后者又相应地创建一个 RecordCursor，openLooKeng 使用该 RecordCursor 来读取每行的列值。
事件侦听器 openLooKeng 支持为以下事件调用的自定义事件侦听器： 创建查询 完成查询（成功或失败） 完成分片（成功或失败） 利用该功能，可以开发自定义日志记录、调试和性能分析插件。在 openLooKeng 集群中，同一时间只有一个事件侦听器插件处于活动状态。 实现 EventListenerFactory 负责创建 EventListener 实例。它还定义管理员在 openLooKeng 配置中使用的 EventListener 名称。EventListener 实现可以实现用于其需要处理的事件类型的方法。 必须将 EventListener 和 EventListenerFactory 的实现包装为一个插件并将其安装在 openLooKeng 集群上。 配置 在协调节点上安装实现 EventListener 和 EventListenerFactory 的插件后，使用 etc/event-listener.properties 文件对其进行配置。除 event-listener.name 之外，所有属性都特定于 EventListener 实现。 Event-listener.name 属性由 openLooKeng 用于根据 EventListenerFactory.getName() 返回的名称查找注册的 EventListenerFactory。其余的属性作为到 EventListenerFactory.create() 的映射进行传递。 配置文件示例： event-listener.name=custom-event-listener custom-property1=custom-value1 custom-property2=custom-value2
Example HTTP 连接器 Example HTTP 连接器有一个简单目标：通过 HTTP 读取逗号分隔的数据。例如，如果您有大量 CSV 格式的数据，您可以将 Example HTTP 连接器指向这些数据并编写 SQL 查询来处理这些数据。 代码 可以在 openLooKeng 源代码树根目录下的 presto-example-http 目录中找到 Example HTTP 连接器。 插件实现 Example HTTP 连接器中的插件实现与其他插件实现非常相似。大部分实现都聚焦于处理可选配置，唯一相关的函数如下所示： @Override public Iterable<ConnectorFactory> getConnectorFactories() { return ImmutableList.of(new ExampleConnectorFactory()); } 请注意，ImmutableList 类是 Guava 提供的一个实用程序类。 与所有连接器一样，该插件会覆盖 getConnectorFactories() 方法并返回一个 ExampleConnectorFactory。 ConnectorFactory Implementation 在 openLooKeng 中，处理 openLooKeng 与特定类型数据源之间连接的主要对象是 Connector 对象，该对象是使用 ConnectorFactory 创建的。 类 ExampleConnectorFactory 中提供了该实现。连接器工厂实现所做的第一件事是指定该连接器的名称。这是用于在 openLooKeng 配置中引用此连接器的同一字符串。 @Override public String getName() { return "example-http"; } 连接器工厂的实际工作在 create() 方法中执行。在 ExampleConnectorFactory 类中，create() 方法配置连接器，然后请求 Guice 创建对象。以下是不含参数校验和异常处理的 create() 方法的内容：
外部函数注册和下推 介绍 openLooKeng系统可以在Connector中注册外部函数到function-namespace-manager中。 并且在Jdbc Connector中还支持下推到数据源执行。 在Connector中注册外部函数 openLooKeng可以通过Connector向系统注册外部函数。我们在Jdbc Connector实现了一个例子，下面我们通过例子来讲解。 用户可以在presto-mysql/src/main/java/io.prestosql/plugin/mysql/optimization/function中找到如何在Jdbc Connector向function-namespace-manager注册外部函数的代码。 在Connector中注册外部函数需要以下两个步骤。 扩展实现下面这个抽象函数类(例如MysqlExternalFunctionHub.java)： public interface ExternalFunctionHub { Set<ExternalFunctionInfo> getExternalFunctions(); RoutineCharacteristics.Language getExternalFunctionLanguage(); CatalogSchemaName getExternalFunctionCatalogSchemaName(); } 这些方法返回Connector需要向function-namespace-manager注册的函数信息。 关于如何实现ExternalFunctionHub，我们在MysqlExternalFunctionHub.java中提供了一个简单明了的例子。 例如对于ExternalFunctionHub#getExternalFunctions方法， 我们通过静态类实例注册的形式来实现ExternalFunctionInfo的实例集合的构造。当然你也可以自己定制代码，通过从外部读取文件等形式来构造ExternalFunctionInfo的实例集合， 也就是你只需要注册和返回一个ExternalFunctionInfo的实例集合即可。 在这里我们仅提供基本的通用框架。 另外，我们仅支持在外部函数中声明下列定义在io.prestosql.spi.type.StandardTypes中的类型。 Supported type StandardTypes.TINYINT StandardTypes.SMALLINT StandardTypes.INTEGER StandardTypes.BIGINT StandardTypes.DECIMAL StandardTypes.REAL StandardTypes.DOUBLE StandardTypes.BOOLEAN StandardTypes.CHAR StandardTypes.VARCHAR StandardTypes.
文件系统访问实用程序 概述 openLooKeng 项目包含一组文件系统客户端实用程序，用于帮助访问和修改文件。当前支持两组文件系统：HDFS 和本地文件系统。SPI 中提供了 HetuFileSystemClient 接口，该接口定义了要在项目中使用的常用文件操作。该客户端的目标是在不同的文件系统上提供统一的接口、行为和异常。因此，客户端代码可以轻松地重用代码，无需更改代码即可传递其逻辑。 SPI 中的实用程序类 FileBasedLock 可以提供对给定的文件系统的独占访问权限。该类利用统一的文件系统客户端接口，因此可用于不同的文件系统。 文件系统客户端实现为 openLooKeng 插件。实现放置在 hetu-filesystem-client 模块中，在该模块中，必须在 HetuFileSystemClientPlugin 中实现和注册一个扩展 HetuFileSystemClientFactory 的工厂。 文件系统配置文件 文件系统配置文件必须包含一个类型字段： fs.client.type=<filesystem type> 可以提供相应的文件系统客户端使用的附加配置。例如，HDFS 文件系统需要配置资源文件 core-site.xml 和 hdfs-site.xml 的路径。如果文件系统启用了身份验证（例如 Kerberos），那么还应在配置文件中指定凭据。 可以将多个定义文件系统客户端的配置文件放置在 etc/filesystem 中。 与目录类似，这些配置文件将在服务器启动时由文件系统管理器加载，该管理器还生成多个文件系统客户端，以在 presto-main 中使用。客户端模块可以自行读取该文件夹中的配置文件，但强烈建议客户端模块获取由主模块提供的客户端，以防止出现依赖问题。 拥有多个配置文件的典型用例是使用并预设多个 HDFS。在这种情况下，为每个集群创建一个属性文件并在不同的配置文件中包含其各自的身份验证信息，例如 hdfs1.properties 和 hdfs2.properties。客户端代码将能够通过指定配置文件名称（文件名）来访问这些属性文件，如 FileSystemClientManager 中的 getFileSystemClient("hdfs1", <rootPath>)。 每一个本地和HDFS的文件系统客户端在构造时都要求一个访问限制的根目录，在访问文件系统时客户端会检查访问的文件或目录是否在这个根目录内，不在此目录内的访问会被禁止。建议在配置时使用满足使用需求的最小的一个目录，以避免不慎修改（或删除）本来不该访问的文件。 文件系统配置文件属性 属性名称 是否必选 说明 默认值 fs.client.type 是 文件系统配置文件的类型。接受的值：local、hdfs。 hdfs.config.resources 否 HDFS 资源文件（例如 core-site.
函数 插件实现 函数框架用于实现 SQL 函数。openLooKeng 包含大量的内置函数。 为了实现新的函数，您可以编写一个插件，用于从 getFunctions() 返回一个或多个函数： public class ExampleFunctionsPlugin implements Plugin { @Override public Set<Class<?>> getFunctions() { return ImmutableSet.<Class<?>>builder() .add(ExampleNullFunction.class) .add(IsNullFunction.class) .add(IsEqualOrNullFunction.class) .add(ExampleStringFunction.class) .add(ExampleAverageFunction.class) .build(); } } 请注意，ImmutableSet 类是 Guava 提供的一个实用程序类。 getFunctions() 方法包含我们将在本教程的下面部分实现的所有函数类。 有关代码库的完整示例，请参见 presto-ml 模块中的机器学习函数或 presto-teradata-functions 模块中与 Teradata 兼容的函数，这两个模块都位于在 openLooKeng 源代码的根目录中。 标量函数实现 函数框架使用注释来表示函数的相关信息，包括名称、说明、返回类型和参数类型。 下面是一个实现 is_null 的示例函数： public class ExampleNullFunction { @ScalarFunction("is_null") @Description("Returns TRUE if the argument is NULL") @SqlType(StandardTypes.BOOLEAN) public static boolean isNull(@SqlNullable @SqlType(StandardTypes.VARCHAR) Slice string) { return (string == null); } } 函数 is_null 接受单个 VARCHAR 参数并返回一个 BOOLEAN 值，指示该参数是否为 NULL。 请注意，该函数的参数类型是 Slice。 VARCHAR 使用 Slice，后者本质上是一个对 byte[] 进行包装的包装器，而不是用于其本地容器类型的 String。
入门指南 要求 Mac OS X或Linux Java 8 Update 161或更高版本(8u161+)（64位）。同时支持Oracle JDK和OpenJDK。 AArch64 (Bisheng JDK 1.8.262 或更高版本) Maven 3.3.9+（用于构建） Python 2.4+（与启动器脚本一起运行） 构建openLooKeng Core openLooKeng Core是一个标准Maven项目。在项目根目录下运行以下命令即可： ./mvnw clean install 在第一次构建中，Maven将从Internet下载所有依赖项并将其缓存在本地存储库(~/.m2/repository)中，这可能需要相当长的时间。后续的构建会更快。 openLooKeng Core有一组全面的单元测试，运行这些测试可能需要几分钟的时间。您可以在构建时禁用这些测试： ./mvnw clean install -DskipTests 在您的IDE中运行openLooKeng Core 概述 首次构建openLooKeng Core之后，您可以将该项目加载到您的IDE中并运行服务器。我们建议使用IntelliJ IDEA。由于openLooKeng是一个标准Maven项目，因此您可以使用根文件pom.xml将其导入到您的IDE中。在IntelliJ中，从“Quick Start”框中选择“Open Project”或从“File”菜单中选择“Open”，然后选择根文件 pom.xml。 在IntelliJ中打开该项目之后，仔细检查是否为该项目正确配置了Java SDK： 打开“File”菜单并选择“Project Structure”。 在“SDKs”部分中，确保选择1.8 JDK（如果不存在，则创建一个）。 在“Project”部分中，确保将“Project language level”设置为8.0，因为openLooKeng Core使用了一些Java 8语言功能。 openLooKeng Core附带的样例配置可以直接用于开发。使用以下选项创建运行配置： Main Class：io.prestosql.server.PrestoServer VM Options：-ea -XX:+UseG1GC -XX:G1HeapRegionSize=32M -XX:+UseGCOverheadLimit -XX:+ExplicitGCInvokesConcurrent -Xmx2G -Dconfig=etc/config.
ORC Cache ORC Cache功能可以通过缓存频繁访问的数据来提高查询性能。ORC Cache减少了TableScan操作所花费的时间，因为减少了网络IO所花费的时间。这又相应地降低了查询延迟。 在缓存访问频率最高且与openLooKeng部署不在同一位置的表中的原始数据时，该功能最有用。启用该功能后，工作节点会自动缓存所有ORC文件的文件尾(file tail)、条带页脚(stripe footer)、行索引、bloom索引，因为它们很小。不过，行组数据往往非常庞大，并且由于缓存大小的限制，为所有文件缓存行组数据实际上并不可行。 单击该链接以了解ORC规范。 可以使用CACHE TABLE SQL命令来配置工作节点缓存行数据的表和分区。 以下各节简要说明了整个行数据缓存实现的工作方式。 SplitCacheMap 用户可以使用CACHE TABLE SQL语句来配置Hive连接器必须缓存的表和数据。要缓存的分区被定义为谓词，并存储在SplitCacheMap中。SplitCacheMap存储在协调节点的本地内存中。 以下是用于缓存2020年1月4日至2020年1月11期间每天的sales表数据的示例查询。 cache table hive.default.sales where sales_date BETWEEN date '2020-01-04' AND date'2020-01-11' 有关更多信息，请查看CACHE TABLE、SHOW CACHE和DROP CACHE命令。 SplitCacheMap存储以下两类信息： 通过CACHE TABLE命令提供的表名和谓词。 分段到工作节点的映射。 连接器 启用缓存并通过CACHE TABLE SQL命令提供谓词后，如果相应的分区ORC文件与谓词匹配，则连接器会将Hive分段标记为可缓存。 SplitCacheAwareNodeSelector 通过实现SplitCacheAwareNodeSelector来支持Cache相关性调度。 SplitCacheAwareNodeSelector与负责将分段分配给工作节点的任何其他节点选择器相同。当第一次调度某个分段时，节点选择器会存储该分段以及为其调度了该分段的工作节点。对于后续调度，会使用该信息来确定是否已经有工作节点处理过该分段。如果已经有工作节点处理过该分段，则节点选择器将该分段调度到先前处理过该分段的工作节点上。如果没有工作节点处理过该分段，SplitCacheAwareNodeSelector将转而使用默认节点选择器来调度分段。 处理分段的工作节点会将分段映射的数据缓存到本地内存中。 工作节点 工作节点依赖ConnectorSplit.isCacheable方法来确定是否必须缓存分段数据。如果属性设置为true，则HiveConnector会尝试从缓存中检索数据。如果缓存未命中，则从HDFS中读取数据并将其存储在缓存中，以供将来使用。工作节点会根据到期时间和是否达到大小限制来清除其缓存，与协调节点无关。 请查看Hive连接器下的ORC Cache Configuration，以了解有关缓存配置的更多信息。
密码验证器 openLooKeng 支持使用用户名和密码通过自定义密码验证器进行身份验证，该验证器验证凭据并创建一个主体。 实现 PasswordAuthenticatorFactory 负责创建一个 PasswordAuthenticator 实例。它还定义管理员在 openLooKeng 配置中使用的该验证器的名称。 PasswordAuthenticator 包含单个方法 createAuthenticatedPrincipal()，该方法验证凭据并返回一个 Principal，然后 system-access-control 对该 Principal 进行授权。 必须将 PasswordAuthenticatorFactory 的实现包装为一个插件并将其安装在 openLooKeng 集群上。 配置 在将实现 PasswordAuthenticatorFactory 的插件安装在协调节点上之后，使用 etc/password-authenticator.properties 文件对其进行配置。除 access-control.name 之外，所有属性都特定于 PasswordAuthenticatorFactory 实现。 password-authenticator.name 属性由 openLooKeng 用于根据 PasswordAuthenticatorFactory.getName() 返回的名称查找注册的 PasswordAuthenticatorFactory。其余的属性作为到 PasswordAuthenticatorFactory.create() 的映射进行传递。 配置文件示例： password-authenticator.name=custom-access-control custom-property1=custom-value1 custom-property2=custom-value2 此外，必须将协调节点配置为使用密码验证并启用 HTTPS。
SPI 概述 当您实现一个新的 openLooKeng 插件时，您将实现多个接口并覆盖 SPI 定义的方法。插件可以提供额外的连接器、类型、函数和系统访问控制。特别地，连接器是用于在 openLooKeng 中进行查询的所有数据的源：它们支持 openLooKeng 可用的每个目录。 代码 可以在 openLooKeng 源代码树根目录下的 presto-spi 目录中找到 SPI 源代码。 插件元数据 每个插件标识一个入口点：Plugin 接口的实现。该类名通过标准 Java ServiceLoader 接口提供给 openLooKeng：classpath 包含 META-INF/services 目录中一个名为 io.prestosql.spi.Plugin 的资源文件。该文件的内容只有一行，其中列出了插件类的名称： com.example.plugin.ExamplePlugin 对于包含在 openLooKeng 源代码中的内置插件，每当插件的 pom.xml 文件包含以下行时，就会创建该资源文件： <packaging>hetu-plugin</packaging> 插件 对于想要了解 openLooKeng SPI 的开发人员而言，Plugin 接口是一个很好的起点。该接口包含用于检索插件可以提供的各种类的访问方法。例如，getConnectorFactories() 方法是一个顶层函数，当 openLooKeng 可以创建连接器实例来支持目录时，openLooKeng 会调用该函数来检索 ConnectorFactory。Type、ParametricType、Function、SystemAccessControl 和 EventListenerFactory 对象具有类似的方法。 通过 Maven 构建插件 插件依赖于 openLooKeng 的 SPI： <dependency> <groupId>io.prestosql</groupId> <artifactId>presto-spi</artifactId> <scope>provided</scope> </dependency> 由于 openLooKeng 在运行时提供来自 SPI 的类，因此插件不应在插件程序集中包含这些类，所以插件使用 Maven provided 范围。
系统访问控制 openLooKeng 将向协调节点进行身份验证的主体与负责运行查询的用户名的概念区分开。 例如，在运行 openLooKeng CLI 时，可以使用 --user 选项来指定 openLooKeng 用户名。 默认情况下，openLooKeng 协调节点允许任何主体以任何 openLooKeng 用户身份运行查询。在安全的环境中，这很可能不是理想的行为，可能需要自定义。 实现 SystemAccessControlFactory 负责创建 SystemAccessControl 实例。它还定义管理员在 openLooKeng 配置中使用的 SystemAccessControl 名称。 SystemAccessControl 实现负责： 验证给定的主体是否有权以特定的用户身份执行查询。 确定给定的用户是否能够更改给定系统属性的值。 对所有目录进行访问检查。这些访问检查在任何特定于连接器的检查之前执行，因此可能拒绝 ConnectorAccessControl 允许的权限。 必须将 SystemAccessControl 和 SystemAccessControlFactory 的实现包装为一个插件并将其安装在 openLooKeng 集群上。 配置 在协调节点上安装实现 SystemAccessControl 和 SystemAccessControlFactory 的插件后，使用 etc/access-control.properties 文件对其进行配置。除 access-control.name 之外，所有属性都特定于 SystemAccessControl 实现。 Access-control.name 属性由 openLooKeng 用于根据 SystemAccessControlFactory.getName() 返回的名称查找注册的 SystemAccessControlFactory。其余的属性作为到 SystemAccessControlFactory.create() 的映射进行传递。 配置文件示例： access-control.name=custom-access-control custom-property1=custom-value1 custom-property2=custom-value2
类型 openLooKeng 中的 Type 接口用于实现 SQL 语言中的类型。openLooKeng 具有大量的内置类型，如 VarcharType 和 BigintType。ParametricType 接口用于为类型提供类型参数，以允许实现 VARCHAR(10) 和 DECIMAL(22, 5) 等类型。Plugin 可以通过从 getTypes() 返回 Type 对象来提供新的 Type 对象，并可以通过从 getParametricTypes() 返回 ParametricType 对象来提供新的 ParametricType 对象。 下面是 Type 接口的简要概述，有关更多详细信息，请参见 JavaDoc 中的 Type。 本地容器类型： 所有类型都定义了 getJavaType() 方法，通常称为“原生容器类型”。这是用于在执行过程中保存值并将其存储在 Block 中的 Java 类型。例如，这是 Java 代码中用于实现生产或消费该 Type 的函数的类型。 本地编码： 对本地容器类型形式的值的解释由其 Type 进行定义。BigintType 等某些类型匹配本地容器类型的 Java 解释（64 位补码）。不过，对于 TimestampWithTimeZoneType（该类型还使用 long 作为其本地容器类型）等其他类型，存储在 long 中的值是一个 8 字节二进制值，该值将时区和 unix 纪元时间以来的毫秒数组合在一起。尤其要注意的是，这意味着在不知道本地编码的情况下，无法比较两个本地值并期望得到有意义的结果。 类型签名：
openLooKeng FAQ 通用问题 openLooKeng开源使用的是什么许可证? openLooKeng使用Apache License 2.0。 openLooKeng是否支持X86和ARM？可以运行在哪些操作系统上? openLooKeng对于X86/ARM均可以支持；对于操作系统，目前openLooKeng支持openEuler、CentOS、openSUSE等Linux操作系统。 如果发现openLooKeng存在漏洞，将如何处理？ 社区有CVE处理流程，如果发现疑似安全问题，可通过 securities@openlookeng.io 通知社区，我们将在第一时间响应并处理。 如何上报一个Bug？ 可以访问openLooKeng社区Issue板块（ https://gitee.com/organizations/openLooKeng/issues ），找到Bug所属的仓库新建Issue并将问题类型选择为缺陷。 如何提交补丁？ 任何人员都可以在openLooKeng社区以Pull Request（简称PR）的形式提交补丁，PR将会由模块Maintainer检视、反馈、合入。具体操作请参考：https://gitee.com/help/articles/4122 openLooKeng的社区版本计划和roadmap？ 2020年6月30日 正式将代码开放到社区，发布openLooKeng v0.1.0版本，与全球开发者一起共建社区。后续规划每3个月发布一个迭代release版本，持续上线新特性。openLooKeng的roadmap会按需发布，请关注openLooKeng社区双周PMC Meeting：https://etherpad.openlookeng.io/p/PMC-weeklymeeting ，或到openLooKeng Slack频道查看。openLooKeng Slack入口连接在： https://openlookeng.io/zh-cn/communication.html 。 哪些渠道可以获取openLooKeng的相关资讯和进行技术交流？ 社区issue： https://gitee.com/openlookeng 官网主页： https://openlookeng.io/zh-cn/ Slack频道: https://openlookeng.slack.com/ openLooKeng公众号：公众号搜索openLooKeng openLooKeng微信群：请添加openLooKeng小助手微信号：openLooKengoss，小助手会拉您入群 openLooKeng B站： https://space.bilibili.com/627629884 openLooKeng基于Trino哪个版本进行开发？
聚合函数 聚合函数对一组值进行操作以计算得出单个结果。 除了 count、count_if、max_by、min_by 和 approx_distinct 之外，所有这些聚合函数都忽略空值，并且对于没有输入行或所有值都是 NULL 的情况都返回 NULL。例如，sum 返回 NULL 而不是零，avg 在计数中不包括 NULL 值。可以使用 coalesce 函数将 NULL 转换为零。 某些聚合函数（如 array_agg）会根据输入值的顺序生成不同的结果。可以通过在聚合函数中写入一个 order-by-clause 来指定该顺序： array_agg(x ORDER BY y DESC) array_agg(x ORDER BY x, y, z) 一般聚合函数 arbitrary(x) -> [与输入相同] 返回 x 的任意非 NULL 值（如果存在）。 array_agg(x) -> array<[与输入相同]> 返回通过输入 x 元素创建的数组。 avg(x) -> double 返回所有输入值的平均值（算术平均值）。 avg(时间间隔类型) -> 时间间隔类型 返回所有输入值的平均间隔长度。 bool_and(boolean) -> boolean 如果每个输入值都为 TRUE，则返回 TRUE，否则返回 FALSE。 bool_or(boolean) -> boolean 如果任一输入值为 TRUE，则返回 TRUE，否则返回 FALSE。
数组函数和运算符 下标运算符： [] [] 运算符用于访问数组中的一个元素，其索引从 1 开始： SELECT my_array[1] AS first_element 连接运算符： || || 运算符用于将数组与一个相同类型的数组或元素进行连接： SELECT ARRAY [1] || ARRAY [2]; -- [1, 2] SELECT ARRAY [1] || 2; -- [1, 2] SELECT 2 || ARRAY [1]; -- [2, 1] 数组函数 array_distinct(x) -> array 删除数组 x 中的重复值。 array_intersect(x, y)-> array 返回 x 与 y 的交集中的元素构成的数组，不含重复元素。 array_union(x, y) -> array 返回 x 与 y 的并集中的元素构成的数组，不含重复元素。 array_except(x, y) -> array
二进制函数和运算符 二进制运算符 || 运算符执行连接。 二进制函数 length(binary) -> bigint 返回 binary 的长度，以字节为单位。 concat(binary1, …, binaryN) -> varbinary 返回 binary1、binary2、...、binaryN 的连接结果。该函数提供与 SQL 标准连接运算符 (||) 相同的功能。 substr(binary, start) -> varbinary 从起始位置 start 开始返回 binary 的其余部分，以字节为单位。位置从 1 开始。负起始位置表示相对于字符串的末尾。 substr(binary, start, length) -> varbinary 从起始位置 start 开始从 binary 返回长度为 length 的子字符串，以字节为单位。位置从 1 开始。负起始位置表示相对于字符串的末尾。 to_base64(binary) -> varchar 将 binary 编码为 base64 字符串表示形式。 from_base64(string) -> varbinary 从以 base64 编码的 string 解码二进制数据。 to_base64url(binary) -> varchar 使用 URL 安全字母表将 binary 编码为 base64 字符串表示形式。
按位运算函数 bit_count(x, bits) -> bigint 获取以二进制补码表示的 x（被视为 bits 位有符号整数）中设置的位的数量。 SELECT bit_count(9, 64); -- 2 SELECT bit_count(9, 8); -- 2 SELECT bit_count(-7, 64); -- 62 SELECT bit_count(-7, 8); -- 6 bitwise_and(x, y) -> bigint 返回以二进制补码表示的 x 和 y 的按位与运算结果。 bitwise_not(x) -> bigint 返回以二进制补码表示的 x 的按位取反运算结果。 bitwise_or(x, y) -> bigint 返回以二进制补码表示的 x 和 y 的按位或运算结果。 bitwise_xor(x, y) -> bigint 返回以二进制补码表示的 x 和 y 的按位异或运算结果。 另请参见 bitwise_and_agg 和 bitwise_or_agg。
颜色函数 bar(x, width) -> varchar 使用默认的low_color 红色和 high_color 绿色呈现 ANSI 条形图中的单个条形。例如，将 x 值 25% 和 width 值 40 传递给该函数，则呈现一个 10 字符红色条形图，后跟 30 个空格，从而创建一个 40 字符条形图。 bar(x, width, low_color, high_color) -> varchar 呈现 ANSI 条形图中具有指定 width 的单个行。参数 x 是处于 [0,1] 范围之内的 double 值。处于范围 [0,1] 之外的 x 值将被截断为值 0 或 1。low_color 和 high_color 捕获颜色以用于水平条形图的两端。例如，如果 x 为 0.5，width 为 80，low_color 为 0xFF0000，high_color 为 0x00FF00，则该函数返回一个 40 字符条形，其颜色从红色 (0xFF0000) 变为黄色 (0xFFFF00)，使用空格对 80 字符条形的其余部分进行填充。 color(string) -> color
比较函数和运算符 比较运算符 运算符 说明 < 小于 > 大于 <= 小于等于 >= 大于等于 = 等于 <> 不等于 != 不等于（该语法不标准，但很常见） 范围运算符：BETWEEN BETWEEN 运算符测试某个值是否处于指定的范围之内。其语法为 value BETWEEN min AND max： SELECT 3 BETWEEN 2 AND 6; 上面显示的语句等效于以下语句： SELECT 3 >= 2 AND 3 <= 6; 要测试某个值是否未处于指定的范围之内，应使用 NOT BETWEEN： SELECT 3 NOT BETWEEN 2 AND 6; 上面显示的语句等效于以下语句：
条件表达式 CASE 标准 SQL CASE 表达式具有两种形式。“简单”形式从左向右搜索每个 value 表达式，直到找到一个等于 expression 的表达式： CASE expression WHEN value THEN result [ WHEN ... ] [ ELSE result ] END 会返回匹配的 value 的 result。如果没有找到任何匹配项，那么如果存在 ELSE 子句，则返回该子句中的 result，否则返回 NULL。示例： SELECT a, CASE a WHEN 1 THEN 'one' WHEN 2 THEN 'two' ELSE 'many' END “搜索”形式从左向右计算每个 boolean condition 的值，直到其中一个为 true 并返回匹配的 result： CASE WHEN condition THEN result [ WHEN ... ] [ ELSE result ] END 如果没有任何条件为 true，那么如果存在 ELSE 子句，则返回该子句中的 result，否则返回 NULL。示例：
转换函数 如果可能的话，openLooKeng 会隐式地将数字和字符值转换为正确的类型。对于任何其他类型，默认情况下，openLooKeng 不会隐式地进行转换。例如，期望返回 varchar 值的查询不会自动将 bigint 值转换为等效的 varchar 值。 必要时，可以显式地将值转换为特定的类型。 或者，您可以启用 implicit conversion 功能，然后 openLooKeng 将尝试自动应用源类型和目标类型之间的转换。 转换函数 cast(value AS type) -> type 将值显式转换为某个类型。可以使用该函数将 varchar 转换为数值类型，反之亦然。 try_cast(value AS type) -> type 与 cast 类似，如果转换失败，则返回 NULL。 格式化 format(format, args…) -> varchar 使用指定的格式字符串和参数返回一个格式化字符串： SELECT format('%s%%', 123); -- '123%' SELECT format('%.5f', pi()); -- '3.14159' SELECT format('%03d', 8); -- '008' SELECT format('%,.2f', 1234567.89); -- '1,234,567.89' SELECT format('%-7s,%7s', 'hello', 'world'); -- 'hello , world' SELECT format('%2$s %3$s %1$s', 'a', 'b', 'c'); -- 'b c a' SELECT format('%1$tA, %1$tB %1$te, %1$tY', date '2006-07-04'); -- 'Tuesday, July 4, 2006' 数据大小 parse_presto_data_size 函数支持以下单位：
日期和时间函数和运算符 日期和时间运算符 运算符 示例 结果 + date '2012-08-08' + interval '2' day 2012-08-10 + time '01:00' + interval '3' hour 04:00:00.000 + timestamp '2012-08-08 01:00' + interval '29' hour 2012-08-09 06:00:00.000 + timestamp '2012-10-31 01:00' + interval '1' month 2012-11-30 01:00:00.000 + interval '2' day + interval '3' hour 2 03:00:00.000 + interval '3' year + interval '5' month 3-5 - date '2012-08-08' - interval '2' day 2012-08-06 - time '01:00' - interval '3' hour 22:00:00.
decimal 函数和运算符 decimal 字面量 可以使用 DECIMAL 'xxxxxxx.yyyyyyy' 语法来定义 DECIMAL 类型的字面量。 DECIMAL 类型的字面量精度将等于字面量（包括尾随零和前导零）的位数。范围将等于小数部分（包括尾随零）的位数。 示例字面量 数据类型 DECIMAL '0' DECIMAL(1) DECIMAL '12345' DECIMAL(5) DECIMAL '0000012345.1234500000' DECIMAL(20, 10) 二进制算术 decimal 运算符 支持标准数学运算符。下表说明了结果的精度和范围计算规则。假设 x 的类型为 DECIMAL(xp, xs)，y 的类型为 DECIMAL(yp, ys)。 运算 结果类型精度 结果类型范围 x + y 和 x - y min(38, 1 + min(xs, ys) + min(xp - xs, yp - ys) ) max(xs, ys) x * y min(38, xp + yp) xs + ys x / y min(38, xp + ys + max(0, ys-xs) ) max(xs, ys) x % y min(xp - xs, yp - ys) + max(xs, bs) max(xs, ys) 如果运算的数学结果无法通过结果数据类型的精度和范围精确地表示，则发生异常情况：Value is out of range。
地理空间函数 以ST_前缀开头的openLooKeng 地理空间函数支持SQL/MM规范，并符合开放地理空间联盟(OGC)的OpenGIS规范。因此，许多openLooKeng地理空间函数要求（更准确地说是假定）所操作的几何图形是简单且有效的。例如，计算在外部定义了一个洞的多边形的面积或者通过非简单边界线构造一个多边形是没有意义的。 openLooKeng地理空间函数支持熟知文本(WKT)和熟知二进制(WKB)形式的空间对象： POINT (0 0) LINESTRING (0 0, 1 1, 1 2) POLYGON ((0 0, 4 0, 4 4, 0 4, 0 0), (1 1, 2 1, 2 2, 1 2, 1 1)) MULTIPOINT (0 0, 1 2) MULTILINESTRING ((0 0, 1 1, 1 2), (2 3, 3 2, 5 4)) MULTIPOLYGON (((0 0, 4 0, 4 4, 0 4, 0 0), (1 1, 2 1, 2 2, 1 2, 1 1)), ((-1 -1, -1 -2, -2 -2, -2 -1, -1 -1))) GEOMETRYCOLLECTION (POINT(2 3), LINESTRING (2 3, 3 4)) 使用ST_GeometryFromText和ST_GeomFromBinary函数可以从WKT或WKB创建几何对象。
HyperLogLog 函数 openLooKeng 使用 HyperLogLog 数据结构实现 approx_distinct 函数。 数据结构 openLooKeng 将 HyperLogLog 数据草图实现为一组存储最大哈希的 32 位数据桶。这些数据桶能够以稀疏（作为数据桶 ID 到数据桶的映射）或密集（作为连续的内存块）的方式存储。HyperLogLog 数据结构以稀疏表示开始，当它更高效时会切换到密集表示。P4HyperLogLog 结构以密集方式初始化，并且在其生命周期内保持密集。 hyperloglog_type 隐式转换为 p4hyperloglog_type，您可以显式地将 HyperLogLog 转换为 P4HyperLogLog： cast(hll AS P4HyperLogLog) 序列化 可以将数据草图序列化为 varbinary，也可以从中反序列化数据草图。这样就可以存储数据草图供以后使用。这与合并多个草图的功能相结合，使您能够计算查询分区元素的 approx_distinct，然后以很小的代价计算整个查询。 例如，计算每日唯一用户的 HyperLogLog 之后，可以通过合并每日数据以增量方式计算每周或每月的唯一用户。这类似于通过汇总每日收入来计算每周收入。可以将 approx_distinct 与 GROUPING SETS 的结合使用转换为使用 HyperLogLog。示例： CREATE TABLE visit_summaries ( visit_date date, hll varbinary ); INSERT INTO visit_summaries SELECT visit_date, cast(approx_set(user_id) AS varbinary) FROM user_visits GROUP BY visit_date; SELECT cardinality(merge(cast(hll AS HyperLogLog))) AS weekly_unique_users FROM visit_summaries WHERE visit_date >= current_date - interval '7' day; 函数 approx_set(x) -> HyperLogLog
JSON函数和运算符 转换为JSON 支持从BOOLEAN、TINYINT、SMALLINT、INTEGER、BIGINT、REAL、DOUBLE或VARCHAR进行转换。当数组的元素类型为支持的类型之一、Map的键类型是VARCHAR且Map的值类型是支持的类型之一或行的每个字段类型是支持的类型之一时支持从ARRAY、MAP或ROW进行转换。下面通过示例展示了转换的行为： SELECT CAST(NULL AS JSON); -- NULL SELECT CAST(1 AS JSON); -- JSON '1' SELECT CAST(9223372036854775807 AS JSON); -- JSON '9223372036854775807' SELECT CAST('abc' AS JSON); -- JSON '"abc"' SELECT CAST(true AS JSON); -- JSON 'true' SELECT CAST(1.234 AS JSON); -- JSON '1.234' SELECT CAST(ARRAY[1, 23, 456] AS JSON); -- JSON '[1,23,456]' SELECT CAST(ARRAY[1, NULL, 456] AS JSON); -- JSON '[1,null,456]' SELECT CAST(ARRAY[ARRAY[1, 23], ARRAY[456]] AS JSON); -- JSON '[[1,23],[456]]' SELECT CAST(MAP_FROM_ENTRIES(ARRAY[('k1', 1), ('k2', 23), ('k3', 456)]) AS JSON); -- JSON '{"k1":1,"k2":23,"k3":456}' SELECT CAST(CAST(ROW(123, 'abc', true) AS ROW(v1 BIGINT, v2 VARCHAR, v3 BOOLEAN)) AS JSON 注意
Lambda表达式 Lambda表达式使用->表示： x -> x + 1 (x, y) -> x + y x -> regexp_like(x, 'a+') x -> x[1] / x[2] x -> IF(x > 0, x, -x) x -> COALESCE(x, 0) x -> CAST(x AS JSON) x -> x + TRY(1 / 0) 大多数SQL表达式都可以用在lambda体中，但有一些例外： 不支持子查询：x -> 2 + (SELECT 3) 不支持聚合：x -> max(y)
逻辑运算符 逻辑运算符 运算符 说明 示例 AND 如果两个值都为真，则为真。 a AND b OR 如果其中一个值为真，则为真。 a OR b NOT 如果值为假，则为真。 NOT a NULL对逻辑运算符的影响 如果表达式的一侧或两侧为NULL，则AND比较的结果可能是NULL。如果AND运算符至少一侧为FALSE，则表达式的计算结果为FALSE： SELECT CAST(null AS boolean) AND true; -- null SELECT CAST(null AS boolean) AND false; -- false SELECT CAST(null AS boolean) AND CAST(null AS boolean); -- null 如果表达式的一侧或两侧为NULL，则OR比较的结果可能是NULL。如果OR运算符至少一侧为TRUE，则表达式的计算结果为TRUE： SELECT CAST(null AS boolean) OR CAST(null AS boolean); -- null SELECT CAST(null AS boolean) OR false; -- null SELECT CAST(null AS boolean) OR true; -- true 下面的真值表展示了如何处理AND和OR中的NULL：
map函数和运算符 下标运算符： [] []运算符用于从map中检索给定键对应的值： SELECT name_to_age_map['Bob'] AS bob_age; map函数 cardinality(x) -> bigint 返回map x的基数（大小）。 element_at(map(K,V), key) -> V 返回给定的key的值，如果键不包含在map中，则返回NULL。 map() -> map<unknown, unknown> 返回一个空map： SELECT map(); -- {} map(array(K), array(V)) -> map(K,V) 返回使用给定的键/值数组创建的map： SELECT map(ARRAY[1,3], ARRAY[2,4]); -- {1 -> 2, 3 -> 4} 另请参见map_agg和multimap_agg，以了解如何创建作为聚合的map。 map_from_entries(array(row(K,V))) -> map(K,V) 返回从给定的项数组创建的map： SELECT map_from_entries(ARRAY[(1, 'x'), (2, 'y')]); -- {1 -> 'x', 2 -> 'y'} multimap_from_entries(array(row(K,V))) -> map(K,array(V)) 返回从给定的项数组创建的多重映射。每个键可以关联多个值： SELECT multimap_from_entries(ARRAY[(1, 'x'), (2, 'y'), (1, 'z')]); -- {1 -> ['x', 'z'], 2 -> ['y']} map_entries(map(K,V)) -> array(row(K,V))
数学函数和运算符 数学运算符 运算符 说明 + 加 - 减 * 乘 / 除（整数除法会进行截断） % 取模（余数） 数学函数 abs(x) -> [与输入相同] 返回x的绝对值。 cbrt(x) -> double 返回x的立方根。 ceil(x) -> [与输入相同] 这是ceiling的别名。 ceiling(x) -> [与输入相同] 返回x向上舍入到最接近的整数后的值。 cosine_similarity(x, y) -> double 返回稀疏向量x和y之间的余弦相似度： SELECT cosine_similarity(MAP(ARRAY['a'], ARRAY[1.0]), MAP(ARRAY['a'], ARRAY[2.0])); -- 1.0 degrees(x) -> double 将角x的弧度转换为角度。 e() -> double 返回常量欧拉数。
分位数摘要函数 openLooKeng使用分位数摘要数据结构实现approx_percentile函数。基础数据结构qdigest在openLooKeng中公开为一种数据类型，可以独立于approx_percentile对其进行创建、查询和存储。 数据结构 分位点摘要是存储近似百分位信息的数据概要。该数据结构的openLooKeng类型称为qdigest，它接受一个参数，该参数必须是bigint、double或real，它们表示可以由qdigest获取的数字集合。可以在不损失精度的情况下对其进行合并，还可以将其与VARBINARY来回转换，以进行存储和检索。 函数 merge(qdigest) -> qdigest 将所有输入qdigest合并为单个qdigest。 value_at_quantile(qdigest(T), quantile) -> T 在给定介于0和1之间的数字quantile的情况下从分位数摘要返回近似百分位值。 values_at_quantiles(qdigest(T), quantiles) -> T 在给定输入分位数摘要和0和1之间的值数组（表示要返回的分位数）的情况下以数组的形式返回近似百分位值。 qdigest_agg(x) -> qdigest<[与x相同]> 返回由x的所有输入值组成的qdigest。 qdigest_agg(x, w) -> qdigest<[与x相同]> 返回由x的所有输入值（使用每项权重w）组成的qdigest。 qdigest_agg(x, w, accuracy) -> qdigest<[与x相同]> 返回由x的所有输入值（使用每项权重w和最大误差accuracy）组成的qdigest。accuracy必须是一个大于0且小于1的值，并且对于所有输入行是一个常量。
正则表达式函数 所有正则表达式函数都使用Java模式语法，但有一些值得注意的例外： 当使用多行模式（通过(?m)标志启用）时，仅将\n识别为行终止符。此外，不支持(?d)标志，不得使用该标志。 不区分大小写的匹配（通过(?i)标志启用）始终以支持Unicode的方式执行。不过，不支持上下文相关和局部相关的匹配。此外，不支持(?u)标志，不得使用该标志。 不支持代理项对。例如，\uD800\uDC00不被视为U+10000，必须将其指定为\x{10000}。对于没有基字符的不占位标记，会错误地处理边界(\b)。 在字符类（如[A-Z123]）中不支持\Q和\E，而应将其视为字面量。 支持Unicode字符类(\p{prop})，但有如下差异： 必须删除名称中的所有下划线。例如，使用OldItalic代替Old_Italic。 必须直接指定脚本，而不使用Is、script=或sc=前缀。示例：\p{Hiragana} 必须使用In前缀指定块。不支持block=和blk=前缀。示例：\p{Mongolian} 必须直接指定类别，而不使用Is、general_category=或gc=前缀。示例：\p{L} 必须直接指定二进制属性，而不使用Is。示例：\p{NoncharacterCodePoint} regexp_extract_all(string, pattern) -> array(varchar) 返回正则表达式pattern在string中匹配的子字符串： SELECT regexp_extract_all('1a 2b 14m', '\d+'); -- [1, 2, 14] regexp_extract_all(string, pattern, group) -> array(varchar) 查找string中出现的所有正则表达式pattern实例并返回捕获组编号group： SELECT regexp_extract_all('1a 2b 14m', '(\d+)([a-z]+)', 2); -- ['a', 'b', 'm'] regexp_extract(string, pattern) -> varchar 返回正则表达式pattern在string中匹配的第一个子字符串： SELECT regexp_extract('1a 2b 14m', '\d+'); -- 1 regexp_extract(string, pattern, group) -> varchar 查找string中出现的第一个正则表达式pattern实例并返回捕获组编号group： SELECT regexp_extract('1a 2b 14m', '(\d+)([a-z]+)', 2); -- 'a' regexp_like(string, pattern) -> boolean
会话信息 提供查询执行环境信息的函数。 current_user -> varchar 返回当前运行查询的用户。 注意 这是SQL标准的一部分，不使用圆括号。
字符串函数和运算符 字符串运算符 ||运算符执行连接。 字符串函数 注意 这些函数假定输入字符串包含有效的UTF-8编码的Unicode代码点。不会显式检查UTF-8数据是否有效，对于无效的UTF-8数据，函数可能会返回错误的结果。可以使用from_utf8来更正无效的UTF-8数据。 此外，这些函数对Unicode代码点进行运算，而不是对用户可见的字符（或字形群集）进行运算。某些语言将多个代码点组合成单个用户感观字符（这是语言书写系统的基本单位），但是函数会将每个代码点视为单独的单位。 lower和upper函数不执行某些语言所需的区域设置相关、上下文相关或一对多映射。 具体而言，对于立陶宛语、土耳其语和阿塞拜疆语，这将返回不正确的结果。 chr(n) -> varchar 以单个字符串的形式返回Unicode代码点n。 codepoint(string) -> integer 返回string的唯一字符的Unicode编码点。 concat(string1, …, stringN) -> varchar 返回string1、string2、...、stringN的连接结果。该函数提供与 SQL 标准连接运算符(||)相同的功能。 hamming_distance(string1, string2) -> bigint 返回string1和string2的汉明距离，即对应字符不同的位置的数量。 请注意，这两个字符串的长度必须相同。 length(string) -> bigint 以字符为单位返回string的长度。 levenshtein_distance(string1, string2) -> bigint 返回string1和string2的Levenshtein编辑距离，即将string1更改为string2所需的最小单字符编辑（插入、删除或替换）数量。 lower(string) -> varchar 将string转换为小写。 lpad(string, size, padstring) -> varchar 使用padstring将string左填充至size个字符。如果size小于string的长度，则结果被截断为size个字符。size不得为负数，并且padstring必须为非空值。 ltrim(string) -> varchar 删除string中的前导空格。 replace(string, search) -> varchar 删除string中的所有search实例。 replace(string, search, replace) -> varchar 将string中search的所有实例替换为replace。 reverse(string) -> varchar 以相反的字符顺序返回string。 rpad(string, size, padstring) -> varchar
Teradata函数 这些函数提供与Teradata SQL的兼容性 字符串函数 char2hexint(string) -> varchar 返回字符串的UTF-16BE编码的十六进制表示形式。 index(string, substring) -> bigint strpos函数的别名。 substring(string, start) -> varchar substr函数的别名。 substring(string, start, length) -> varchar substr函数的别名。 日期函数 该部分中的函数使用与Teradata日期时间函数兼容的格式字符串。下表基于Teradata参考手册，描述了支持的格式说明符： 说明符 说明 - / , . ; : 忽略标点符号 dd 一个月中的第几日(1–31) hh 一天中的第几个小时(1–12) hh24 一天中的第几个小时(0–23) mi 分钟(0–59) mm 月份（01–12） ss 秒(0–59) yyyy 四位年份 yy 两位年份 警告
URL函数 提取函数 URL提取函数从HTTP URL（或任何符合2396标准的有效URI）中提取组成部分。支持以下语法： [protocol:][//host[:port]][path][?query][#fragment] 提取的组成部分不包含:或?等URI语法分隔符。 url_extract_fragment(url) -> varchar 从url返回片断标识符。 url_extract_host(url) -> varchar 从url返回主机。 url_extract_parameter(url, name -> varchar 从url返回第一个名为name的查询字符串参数的值。按照1866#section-8.2.1中指定的典型方式来处理参数提取。 url_extract_path(url) -> varchar 从url返回路径。 url_extract_port(url) -> bigint 从url返回端口号。 url_extract_protocol(url) -> varchar 从url返回协议。 url_extract_query(url) -> varchar 从url返回查询字符串。 编码函数 url_encode(value) -> varchar 通过对value进行编码来对其进行转义，以便可以安全地将其包含在URL查询参数名称和值中： 不对字母数字字符进行编码。 不对字符.、-、*和_进行编码。 将ASCII空格字符编码为+。 将所有其他字符都转换为UTF-8，将字节编码为字符串%XX，其中XX是UTF-8字节的大写十六进制值。 url_decode(value) -> varchar 对URL编码value进行反转义。该函数是url_encode的反函数。
UUID函数 uuid() -> uuid 返回伪随机生成的UUID类型（类型4）。
窗口函数 窗口函数对查询结果中的行执行计算。窗口函数在HAVING子句之后、ORDER BY子句之前运行。调用窗口函数需要使用特殊的语法（使用OVER子句来指定窗口）。一个窗口由三部分组成： 分区规范，它将输入行划分到不同的分区中。这与GROUP BY子句将行划分到不同的组中以用于聚合函数的方式类似。 排序规范，它确定窗口函数处理输入行的顺序。 窗口框架，它为给定的行指定要由函数处理的行滑动窗口。如果未指定框架，则默认使用RANGE UNBOUNDED PRECEDING，它与RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW相同。该框架包含从分区开头开始到当前行的最后一个对等点的所有行。 例如，以下查询按价格对每个售货员的订单进行排序： SELECT orderkey, clerk, totalprice, rank() OVER (PARTITION BY clerk ORDER BY totalprice DESC) AS rnk FROM orders ORDER BY clerk, rnk 聚合函数 通过添加OVER子句，可以将所有aggregate用作窗口函数。会为当前行的窗口框架中的每个行计算聚合函数。 例如，以下查询为每个售货员生成按天滚动的订单价格总和： SELECT clerk, orderdate, orderkey, totalprice, sum(totalprice) OVER (PARTITION BY clerk ORDER BY orderdate) AS rolling_sum FROM orders ORDER BY clerk, orderdate, orderkey 排序函数 cume_dist() -> bigint
BitmapIndex（位图索引） BitmapIndex使用Bitmap来进行早期行过滤，这可以帮助减少CPU和内存使用量。 这在高并发queries中是有益的。 BitmapIndex对于低基数（low cardinality, 即不同数据值的个数不多）的列效果很好， 因为index的大小随着不同值数量的增加而增加。 例如，gender之类的列将具有较小的尺寸。 而像id这样的列有很多不同的值，因此不推荐使用位图索引。 Bitmap是为每个不同的值构造一个位图，并记录包含该值的行号。 然后，B+Tree会被用来存储值与其位图之间的映射。 通过使用B+Tree，BitmapIndex可以支持使用运算符之类的范围query，例如 大于（>），小于（<），BETWEEN等。 注意： 在ORC算子下推启用时，BitmapIndex效果更好。可以通过设置hive.properties中的hive.orc-predicate-pushdown-enabled=true来启用， 或者在命令行中启用set session hive.orc_predicate_pushdown_enabled=true;。 参见Properties获得更多信息。 使用场景 注意：当前，启发式索引仅支持ORC存储格式的Hive数据源。 BitmapIndex用于过滤从ORC文件中读取的数据，且仅供worker节点使用。 选择适用的列 以高并发数运行的queries，并且在低基数的列上过滤predicates可以从BitmapIndex中得到好的效果。 例如，类似SELECT * FROM Employees WHERE gender='M' AND type='FULLTIME' AND salary>10000的query 可以在gender和type列上用BitmapIndex并且得到好的效果，因为数据在两列上都被过滤，并且两者的基数都很低。 支持的运算符 = Equality > Greater than >= Greater than or equal < Less than <= Less than or equal BETWEEN Between range IN IN set 支持的列类型 "integer", "smallint", "bigint", "tinyint", "varchar", "char", "boolean", "double", "real", "date", "decimal" 注意: 不支持采用其它数据类型来创建index。
BloomIndex BloomIndex使用Bloom Filters(布隆过滤器)来在计划期间和读取数据时进行过滤。 BloomIndex对于具有高基数（有许多不同值）的列以及索引大小很小的列都适用。 布隆过滤器是使用列值构造的。然后在查找过程中，布隆过滤器会告诉我们布隆过滤器中是否有给定值。 BloomIndex仅支持相等表达式，例如name='monkey'。 使用场景 注意：当前，启发式索引仅支持ORC存储格式的Hive数据源。 BloomIndex用于调度时的分片过滤，被coordinator节点使用。 BloomIndex也用于worker节点上，用于在读取ORC文件时过滤stripes。 选择适用的列 在具有高基数（即许多独特值）条件的列上具有过滤predicate的queries可以从BloomIndex中得到好的效果。 例如，类似SELECT name FROM users WHERE phone=123456789之类的query 可以通过在phone列上使用BloomIndex而得到好的效果，因为列中的数据已被过滤，phone列的基数较高。 支持的运算符 = Equality 支持的列类型 "integer", "smallint", "bigint", "tinyint", "varchar", "char", "boolean", "double", "real", "date", "decimal" 注意: 不支持采用其它数据类型来创建index。 配置参数 bloom.fpp 类型: Double 默认值: 0.001 改变布隆过滤器的FPP (false positive probability)。 更小的FPP会提高索引的过滤能力，但是会增加索引的体积。在大多数情况下默认值就足以够用。 如果创建的索引太大，可以考虑增加这个值（例如：0.05)。 bloom.mmapEnabled 类型: Boolean 默认值: true 控制在读取布隆索引时是否应使用内存映射文件 (mmap)。 启用此值将在读取期间将 Bloom 索引缓存到本地磁盘而不是内存中。 这将减少内存消耗，但会导致性能略有下降。
BTreeIndex BTreeIndex使用二叉树数据结构存储。索引的大小随着索引列中不同值的个数而增加。 BTreeIndex利用B+Tree数据结构来允许在调度期间进行过滤。 BTreeIndex与BloomIndex相似，并且对于具有高基数的列非常适用。 但是，索引的大小可能会很大，因为索引的大小会随着数量的增加而增加 列中独特值的百分比增加。 B+Tree的建立构造使用独特列值作为键，并且可以在其中找到该列值的值。 为了减小索引的大小，将为这些值创建一部Dictionary，因此不需要将大型重复项存储多次。 与BloomIndex不同，BTreeIndex还可以使用以下运算符来支持范围查询 大于（>），小于（<），BETWEEN等。 使用场景 注意：当前，启发式索引仅支持ORC存储格式的Hive数据源。 BTreeIndex用于调度时的分片(Split)过滤，被coordinator节点使用。 选择适用的列 在具有高基数（即许多独特值）条件的列上具有过滤predicate的queries可以从BTreeIndex中达到好的效果。 例如，类似SELECT FROM FROM users WHERE phone>123456789的query 可以通过在phone列上使用BTreeIndex而达到好的效果，因为 列中的数据已被过滤，phone列的基数较高。 在BTreeIndex和BloomIndex索引之间选择时，需要考虑： BloomIndex只支持=，而BTreeIndex提供范围查询 BloomIndex是不确定的，而BTreeIndex是确定的。因此BTreeIndex通常有更好的过滤性能 BTreeIndex比BloomIndex索引更大 支持的运算符 = Equality > Greater than >= Greater than or equal < Less than <= Less than or equal BETWEEN Between range IN IN set 支持的列类型 "integer", "smallint", "bigint", "tinyint", "varchar", "double", "real", "date", "decimal" 注意: 不支持采用其它数据类型来创建index。 用例 创建索引:
使用 索引命令行接口集成于hetu-cli中, 在安装目录的bin目录下运行。 创建 索引创建方法如下: CREATE INDEX [ IF NOT EXISTS ] index_name USING [ BITMAP | BLOOM | BTREE | MINMAX ] ON tbl_name (col_name) WITH ( 'level' = ['STRIPE', 'PARTITION'], "autoload" = true, "bloom.fpp" = '0.001', "bloom.mmapEnabled" = false, [, …] ) WHERE predicate; WHERE 用于选择部分分区创建索引 WITH 用于设置索引属性。参见各个索引的文档来查看支持的配置 "level"='STRIPE' 如缺省，默认创建级别是STRIPE "autoload" 覆盖 config.properties 中的默认值 hetu.heuristicindex.filter.cache.autoload-default。 索引创建或更新后，是否自动加载到缓存中。 如果为 false，将根据需要加载索引。这意味着，前几个查询可能不会使用索引，因为它正在加载到缓存中。 将此设置为 true 可能会导致高内存使用率，但会提供最佳结果。 如果表是分区的，可以用一个等于表达式来指定一个创建的分区，或使用IN来指定多个。 CREATE INDEX index_name USING bloom ON hive.
MinMaxIndex MinMaxIndex简单地记录数据的最大和最小值，占用空间极小。 因此，这一索引仅仅能被用于已经排序的数据列。 使用场景 注意：当前，启发式索引仅支持ORC存储格式的Hive数据源。 MinMaxIndex用于调度时的分片过滤，被coordinator节点使用。 选择适用的列 在对数据进行排序的列上具有过滤predicate的query可以从MinMaxIndex中得到好的效果。 例如，如果以下数据是根据age来排序的，那么一个像SELECT name from users WHERE age> 25 之类的query则可以因有效地在age上利用MinMaxIndex，而从中得到好的效果。 支持的运算符 = Equality > Greater than >= Greater than or equal < Less than <= Less than or equal 支持的列类型 "integer", "smallint", "bigint", "tinyint", "varchar", "char", "boolean", "double", "real", "date", "decimal" 注意: 不支持采用其它数据类型来创建index。 用例 创建索引: create index idx using minmax on hive.hindex.users (age); create index idx using minmax on hive.hindex.users (age) where regionkey=1; create index idx using minmax on hive.
创建自定义索引 基本概念 ID 每一个索引类型都必须有一个ID变量作为其唯一标识符。这一名称将用于CLI，服务器配置，存储索引的文件路径中等各种场合，用于唯一地确定这一索引类型。 Index接口的getID()方法会将索引的ID返回给它的使用者。 Level （数据）层级 启发式索引用各种不同的方法，存储了在原始数据之外额外并且通常更小的信息，用于提高随机查询的效率。因此，每一条索引都必须有它作用的数据域范围。例如，如果一个索引 记录了数据集的"最大"数值，那这一"最大"数值必须拥有它作用的范围（可以是一组数据行，也可以是一个数据分区，甚至整张数据表的最大值）。当创建一个新的索引类型是，必须 实现Set<Level> getSupportedIndexLevels(); 方法来告知它可以支持的数据层级。这些层级由Index接口中的一个枚举类型定义。 接口概览 索引方法 除了上面提到的方法以外，这一段落将介绍其他几个实现新索引类型最重要的方法。要获取Index接口的完整文档，请参阅源代码的Java Doc。 Index接口有两个最重要的方法： boolean matches(Object expression) throws UnsupportedOperationException; <I> Iterator<I> lookUp(Object expression) throws UnsupportedOperationException; 第一个matches()方法接收一个表达式对象，并返回基于索引存储的信息，表达式对应的数据是否可能存在。例如，如果一个索引标记了数据中的最大值，那他可以容易地判断col_val > 5是否可能成立。 第二个方法lookUp()不是必须的。在返回数据是否可能存在以外，他还能返回一个迭代器来返回数据可能存在的位置。对于一个索引，它的matches()方法和lookUp().hasNext()应当总是返回相同的结果。 插入和存取索引 下面的几个方法用于向一个索引中添加值，以及在磁盘上存储/读取索引实例： boolean addValues(Map<String, List<Object>> values) throws IOException; Index deserialize(InputStream in) throws IOException; void serialize(OutputStream out) throws IOException; 这些方法的使用非常直观。为了更好地理解他们的用法，MinMaxIndex的源代码可以作为一个很好的例子。在这个索引中，添加数据仅仅需要通过新的数据更新max和min变量即可。 serialize()/deserialize()方法则只需要向/从磁盘写入/读取最大和最小值这两个值。
openLooKeng启发式索引 简介 可以在数据库表的一个或多个列创建索引，从而提供更快的随机查找。大多数大数据格式，如ORC、Parquet和CarbonData，都已经内置了索引。 启发式索引允许在现有数据上创建索引，但将索引存储在外部的的原始数据源中。这样做好处如下： 索引对底层数据源不可知，并且可由任何查询引擎使用 无需重写现有数据文件即可对现有数据进行索引 可以创建底层数据源不支持的新索引类型 索引数据不占用数据源存储空间 使用场景 注意：当前，启发式索引仅支持ORC存储格式的Hive数据源。 BloomIndex，MinMaxIndex和BtreeIndex可以在Coordinator上使用，以在调度期间过滤Splits 在读取ORC文件时，可以在worker上使用MinMaxIndex或者BloomIndex过滤Stripes 在读取ORC文件时，可以在worker上使用BitmapIndex过滤数据行 1.查询过程中过滤预定分片 支持的索引：BloomIndex, BTreeIndex, MinMaxIndex 当引擎需要调度一个TableScan操作时，它可以调度worker节点上的Split。这些Split负责读取部分源数据。但是如果应用了predicates，则并非所有Split都会返回数据。 例如，select * from test_base where j1='070299439' 通过为predicate列保留外部索引，启发式索引可以确定每个Split是否包含正在搜索的值，并且只对可能包含该值的Split安排读操作。 2.读取ORC文件时提前筛选Stripes 支持的索引：BloomIndex, MinMaxIndex 与分片过滤类似，当使用Hive Connector读取ORC文件时，Stripes可以被提前过滤来减少读取的数据量，从而提升查询性能。 3.读取ORC文件时筛选行 支持的索引：BitmapIndex 当需要从ORC文件中读取数据时，如果有一个predicate存在，那么就不需要批量读取中的所有行。 通过为predicate列保留外部位图索引，将实现只读取匹配当行，来提升内存和处理器表现。在服务器高并发时提升尤其明显。 示例教程 这一教程将通过一个示例查询语句来展示索引的用法。 1. 配置索引 启发式索引需要配置几个组件才能工作。 确保集群中的所有节点都以相同的方式配置,使用相同的hetu文件系统和Metastore等. a. Hetu Metastore Heuristic Index 使用 Hetu Metastore 来管理其元数据。 Hetu Metastore 是一个共享元数据管理实用程序，多个 openLooKeng 功能使用它。 有关如何配置它的更多信息， 请参考 Hetu Metastore. 注意: 必须启用全局缓存！ 如果Hetu Metastore 配置不正确，启发式索引将不起作用。 以下是参考etc/hetu-metastore.properties: hetu.metastore.type=hetufilesystem hetu.metastore.hetufilesystem.profile-name=hdfs # 此路径在 hdfs 内 hetu.
基准驱动 基准驱动可用于测量openLooKeng集群中查询的性能。我们用它来连续测量主干的性能。 从Maven Central下载合适版本的基准驱动可执行Jar文件，例如presto-benchmark-driver-1.0.1-executable.jar，重命名为presto-benchmark-driver后，使用chmod +x使其可执行。如果预期版本不存在，可以使用1.0.1。 套件 创建suite.json文件： { "file_formats": { "query": ["single_.*", "tpch_.*"], "schema": [ "tpch_sf(?<scale>.*)_(?<format>.*)_(?<compression>.*?)" ], "session": {} }, "legacy_orc": { "query": ["single_.*", "tpch_.*"], "schema": [ "tpch_sf(?<scale>.*)_(?<format>orc)_(?<compression>.*?)" ], "session": { "hive.optimized_reader_enabled": "false" } } } 此示例包含两个套件file_formats和legacy_orc。file_formats套件将在与正则表达式tpch_sf.*_.*_.*?匹配的所有模式中运行名称与正则表达式single_.*或tpch_.*匹配的查询。legacy_orc套件添加了一个会话属性来禁用优化的ORC阅读器，并且只在tpch_sf.*_orc_.*?模式中运行。 查询 SQL文件包含在名为sql的目录中，并且必须具有.sql文件扩展名。查询的名称是不带扩展名的文件名。 输出 基准驱动将测量挂钟时间、所有openLooKeng进程使用的CPU总时间以及查询使用的CPU时间。对于每次计时，驱动报告查询运行的中位数、平均值和标准偏差。进程CPU时间和查询CPU时间之差是查询开销，这通常是垃圾收集器造成的。下面是上述file_formats套件的输出： suite query compression format scale wallTimeP50 wallTimeMean wallTimeStd processCpuTimeP50 processCpuTimeMean processCpuTimeStd queryCpuTimeP50 queryCpuTimeMean queryCpuTimeStd ============ ============== =========== ====== ===== =========== ============ =========== ================= ================== ================= =============== ================ =============== file_formats single_varchar none orc 100 597 642 101 100840 97180 6373 98296 94610 6628 file_formats single_bigint none orc 100 238 242 12 33930 34050 697 32452 32417 460 file_formats single_varchar snappy orc 100 530 525 14 99440 101320 7713 97317 99139 7682 file_formats single_bigint snappy orc 100 218 238 35 34650 34606 83 33198 33188 83 file_formats single_varchar zlib orc 100 547 543 38 105680 103373 4038 103029 101021 3773 file_formats single_bigint zlib orc 100 282 269 23 38990 39030 282 37574 37496 156 请注意，上面的输出已重新格式化，以提高驱动输出的标准TSV的可读性。
命令行接口 openLooKeng CLI提供了一个基于终端的交互shell，用于运行查询。CLI是一个可执行的JAR文件，可以通过java -jar ./hetu-cli-*.jar执行。 下载于服务器对应版本的 CLI 文件，例如：hetu-cli-1.0.0-executable.jar，运行： java -jar ./hetu-cli-1.0.0-executable.jar --server localhost:8080 --catalog hive --schema default 使用--help选项运行CLI，查看可用选项。 默认情况下，使用less程序将查询结果分页，该程序配置了一组精心选择的选项。可以通过将环境变量OPENLOOKENG_PAGER设置为其他程序的名称（如more）或将其设置为空值来完全禁用分页来覆盖此行为。
自动部署openLooKeng 除了手动部署openLooKeng服务器外，还可以按照以下指导更快、更容易地完成部署。这个脚本对大多数Linux操作系统都很友好。但是，对于Ubuntu，需要手动安装以下依赖项。 sshpass1.06及以上版本 yum install sshpass 在单个节点上部署openLooKeng 执行以下命令可以帮助你一键下载所需的软件包和部署openLooKeng服务器： bash <(wget -qO- https://download.openlookeng.io/install.sh) 或： wget -O - https://download.openlookeng.io/install.sh|bash 通常情况下，你只需等待安装完成。服务会自动启动。 执行以下命令停止openLooKeng服务： /opt/openlookeng/bin/stop.sh 执行以下命令启动openLooKeng命令行客户端。 /opt/openlookeng/bin/openlk-cli 将openLooKeng在线部署到集群 执行以下命令，按照提示分別输入coordinator、worker节点ip，安装openLooKeng多节点集群： bash <(wget -qO- https://download.openlookeng.io/install.sh) -m 或： bash <(wget -qO- https://download.openlookeng.io/install.sh) --multi-node 首先，该命令将下载openLooKeng服务所需的脚本和包。下载完成后，会检查依赖包expect和sshpass是否安装。如果没有，这些依赖项将自动安装。 另外，jdk版本要求大于1.8.0_151。如果未安装，则集群中会安装jdk1.8.0_201。建议在安装openLooKeng服务之前手动安装这些依赖。 其次，该脚本将下载openLooKeng-server tarball，并将该tarball复制到集群中的所有节点。然后使用此tarball安装openLooKeng-server。 最后，该脚本将使用标准配置安装openLooKeng服务器，包括JVM、Node的配置以及tpch、tpcds、memory connector之类的内置目录的配置。 根据设计，脚本会检查/home/openlkadmin/.openlkadmin/cluster_node_info目录下是否有已有配置： 如果缺少该文件，安装脚本会要求用户输入节点信息。 或者，可以添加用户openlkadmin并创建文件/home/openlkadmin/.openlkconf/cluster_node_info。 在cluster_node_info中，你应该列出适合集群的值。 请参考以下模板，将中括号中的变量替换为实际值。 COORDINATOR_IP=<master_node_ipaddress> WORKER_NODES=<ip_address_1>[,<ip_address_2>,...,<ip_address_n>] openLooKeng的协调节点和工作节点的通用配置从配置文件/home/openlkadmin/.openlkadmin/cluster_config_info中获取，连接器的配置从目录/home/openlkadmin/.openlkadmin/catalog中获取。执行部署脚本时，如果缺少这些目录或者缺少必要的配置文件，则会自动生成默认配置文件，并部署到所有节点。 这意味着，如果希望自定义部署，也可以在运行此部署脚本之前添加这些配置文件。 如果上述过程全部成功，部署脚本将自动启动openLooKeng服务。执行以下命令停止openLooKeng服务： /opt/openlookeng/bin/stop.sh 执行以下命令启动openLooKeng命令行客户端。 /opt/openlookeng/bin/openlk-cli 提示： 如果想将openLooKeng部署到一个节点较多的大集群中，而不逐个输入节点的IP地址，则最好准备一个包含所有节点IP地址的文件，然后将该文件作为参数传递给安装脚本。命令如下： bash <(wget -qO- https://download.openlookeng.io/install.sh) -f <cluster_node_info_path> 或： bash <(wget -qO- https://download.openlookeng.io/install.sh) --file <cluster_node_info_path> 更多帮助信息，请执行以下命令部署单节点集群：
部署具有高可用（HA）的openLooKeng openLooKeng HA解决协调节点单点故障问题。用户可以在任何协调节点上提交查询，以平衡工作负载。 安装HA 安装具有HA的openLooKeng要求集群中至少有2个协调节点。请确保协调节点上的时间一致性。请按照手动部署openLooKeng或自动部署openLooKeng进行基本设置。 配置HA 当前状态存储被用于HA和动态过滤功能特性。 配置协调节点和工作节点属性 在所有协调节点上的etc/config.properties中添加如下配置。 hetu.multiple-coordinator.enabled=true hetu.embedded-state-store.enabled=true 在所有工作节点上的etc/config.properties中添加如下配置。 hetu.multiple-coordinator.enabled=true 上述属性说明如下： hetu.multiple-coordinator.enabled: 启用多个协调节点。 hetu.embedded-state-store.enabled: 协调节点启用嵌入式状态存储。 说明：建议在所有协调节点（或至少3个）上启用嵌入式状态存储，以确保节点/网络关闭时,服务可以保持高可用性。 配置状态存储区 关于配置状态存储, 请参考状态存储。 HA及反向代理 要尽可能的显示HA的优势，建议客户端(例如openLooKeng CLI, JDBC等)不直接连接特定的协调节点，而是通过反向代理连接多个协调节点，例如使用负载平衡器或者Kubernetes服务，这样即使某个协调节点无法正常工作，客户端也可以继续使用其它的协调节点。 反向代理要求 通过反向代理连接时，要求客户端在执行语句查询期间连接到同一协调器，确保在语句查询运行时客户端和协调器之间保持恒定心跳。这可以通过配置反向代理实现，例如Nginx的ip_hash。 配置反向代理 (Nginx) 请在Nginx配置文件中包含以下配置（nginx.conf）。 http { ... # 用户自定义配置 upstream backend { ip_hash; server <coordinator1_ip>:<coordinator1_port>; server <coordinator2_ip>:<coordinator2_port>; server <coordinator3_ip>:<coordinator3_port>; ... } server { ... # 用户自定义配置 location / { proxy_pass http://backend; proxy_set_header Host <nginx_ip>:<nginx_port>; } } }
手动部署openLooKeng 这是一种手动部署方法，你也可以通过脚本使用自动部署方法。（参见自动部署openLooKeng） 安装openLooKeng 下载openLooKeng服务器tarball并解压缩。tarball包含一个顶级目录，我们将其称为安装目录。 openLooKeng需要一个数据目录来存储日志等。我们建议在安装目录之外创建一个数据目录，这样在升级openLooKeng时可以很容易地保留数据目录。 配置openLooKeng 在安装目录下创建etc目录。目录下包括以下配置： 节点属性：每个节点特有的环境配置。 JVM配置：Java虚拟机的命令行选项。 配置属性：openLooKeng服务器的配置。 目录属性：连接器（数据源）配置。 节点属性 节点属性文件etc/node.properties包含每个节点特有的配置。节点是机器上已安装的openLooKeng的单个实例。该文件通常在首次安装openLooKeng时由部署系统创建。下面是最基本的etc/node.properties： node.environment=openlookeng node.launcher-log-file=/opt/openlookeng/hetu-server-1.1.0/log/launch.log node.server-log-file=/opt/openlookeng/hetu-server-1.1.0/log/server.log catalog.config-dir=/opt/openlookeng/hetu-server-1.1.0/etc/catalog node.data-dir=/opt/openlookeng/hetu-server-1.1.0/data plugin.dir=/opt/openlookeng/hetu-server-1.1.0/plugin 上述属性说明如下： node.environment：环境名称。同一集群内所有openLooKeng节点的环境名称必须相同。 node.data-dir：数据目录的位置（文件系统路径）。openLooKeng将在这里存储日志和其他数据。 node.launcher-log-file: launch.log文件。此日志由启动器创建，连接到服务器的stdout和stderr流。此日志将包含一些在初始化服务器日志记录时发生的日志消息，以及JVM产生的任何错误或诊断信息。 node.server-log-file: server.log文件。这是openLooKeng使用的主要日志文件。如果服务器在初始化期间失败，此日志通常会包含相关信息。此日志会自动轮转和压缩。 catalog.config-dir: 创建目录属性文件来注册目录。openLooKeng通过连接器访问数据，连接器挂载在目录中。 plugin.dir: plugin目录位置。 注：具体路径根据openLooKeng实际安装路径修改，比如例子中openLooKeng的安装路径为：/opt/openlookeng/hetu-server-1.1.0/。 JVM配置 JVM配置文件etc/jvm.config包含用于启动Java虚拟机的命令行选项列表。文件的格式是一个选项列表，每行一个选项。这些选项不由shell解释，因此包含空格或其他特殊字符的选项不应被引用。 以下为创建etc/jvm.config提供了一个良好的起点： -server -Xmx16G -XX:-UseBiasedLocking -XX:+UseG1GC -XX:G1HeapRegionSize=32M -XX:+ExplicitGCInvokesConcurrent -XX:+ExitOnOutOfMemoryError -XX:+UseGCOverheadLimit -XX:+HeapDumpOnOutOfMemoryError -XX:+ExitOnOutOfMemoryError 参数中Xmx大小为服务器可用内存的70%（建议值，availableMem*70%）。 由于OutOfMemoryError通常会使JVM处于不一致的状态，因此我们编写一个堆转储（用于调试），并在出现这种情况时强制终止进程。 配置属性 配置属性文件etc/config.properties包含openLooKeng服务器的配置。每个openLooKeng服务器都可以同时充当协调节点和工作节点，但是将一台机器专用于只执行协调工作可以在较大的集群上提供最佳性能。 协调器的最基本配置如下： coordinator=true node-scheduler.include-coordinator=false http-server.http.port=8080 query.max-memory=50GB query.max-total-memory=50GB query.
JDBC驱动 可以使用JDBC驱动从Java访问openLooKeng，并将其添加到Java应用的类路径中。 从版本1.0.1开始，该驱动也可从Maven Central获得。请指定合适的版本： <dependency> <groupId>io.hetu.core</groupId> <artifactId>hetu-jdbc</artifactId> <version>1.0.1</version> </dependency> 驱动名称 驱动类名为io.hetu.core.jdbc.OpenLooKengDriver。大多数用户不需要此信息，因为驱动是自动加载的。 连接 JDBC URL支持如下格式： jdbc:lk://host:port jdbc:lk://host:port/catalog jdbc:lk://host:port/catalog/schema 例如，使用以下URL连接到运行于example.net端口8080的openLooKeng，其目录为hive，模式为sales： jdbc:lk://example.net:8080/hive/sales 可以使用上面的URL创建连接，如下所示： String url = "jdbc:lk://example.net:8080/hive/sales"; Connection connection = DriverManager.getConnection(url, "test", null); 连接参数 该驱动支持各种参数，这些参数可以设置为URL参数或作为传递给DriverManager的属性。以下两个示例是等效的： // URL parameters String url = "jdbc:lk://example.net:8080/hive/sales"; Properties properties = new Properties(); properties.setProperty("user", "test"); properties.setProperty("password", "secret"); properties.setProperty("SSL", "true"); Connection connection = DriverManager.getConnection(url, properties); // properties String url = "jdbc:lk://example.net:8080/hive/sales?user=test&password=secret&SSL=true"; Connection connection = DriverManager.getConnection(url); 这些方法可以混合使用；一些参数可以在URL中指定，而另一些参数则使用属性指定。但是相同的参数不可同时用两种方法指定。 参数参考 项目 描述 user 用于身份验证和授权的用户名。 password 用于LDAP身份验证的密码。 socksProxy SOCKS代理主机和端口。示例：localhost:1080 httpProxy HTTP代理主机和端口。示例：localhost:8888 applicationNamePrefix 添加到任何指定的ApplicationName客户端信息属性的前缀，该前缀用于设置openLooKeng查询的源名称。如果既没有设置该属性也没有设置ApplicationName，则查询的源将是presto-jdbc。 accessToken 基于令牌身份验证的访问令牌。 SSL 使用HTTPS连接。 SSLKeyStorePath 包含用于身份验证的证书和私钥的JavaKeyStore文件的位置。 SSLKeyStorePassword KeyStore密码。 SSLTrustStorePath 用于验证HTTPS服务器证书的Java TrustStore文件的位置。 SSLTrustStorePassword TrustStore密码。 KerberosRemoteServiceName openLooKeng协调节点Kerberos服务的名称。Kerberos认证时，需要配置该参数。 KerberosPrincipal 向openLooKeng协调节点进行身份验证时使用的主体。 KerberosUseCanonicalHostname 通过首先将主机名解析为IP地址，然后对该IP地址执行反向DNS查找，从而使用Kerberos服务主体的openLooKeng协调节点的规范主机名。此参数默认启用。 KerberosServicePrincipalPattern openLooKeng协调节点Kerberos服务主体模式。默认值为${SERVICE}@${HOST}。${SERVICE}替换为KerberosRemoteServiceName的值，${HOST}替换为协调节点的主机名（如果启用了规范化，则为规范化后的主机名）。 KerberosConfigPath Kerberos配置文件。 KerberosKeytabPath Kerberos keytab文件。 KerberosCredentialCachePath Kerberos凭证缓存。 extraCredentials 连接外部服务的额外凭证。ExtraCredentials是一个键值对列表。示例：foo:bar;abc:xyz将创建凭据abc=xyz和foo=bar。
openLooKeng ODBC用户手册 总览 介绍 本用户手册包含Windows版本的openLooKeng ODBC驱动程序的相关信息。包括驱动的安装与ODBC数据源的配置以及驱动的基本信息。 ODBC(Open Database Connectivity 开放数据连接)是微软提出的一个能让应用访问不同DBMS的互操作接口协议，其定义了一个通用的数据库访问机制并提供了一组访问数据库的应用程序编程接口(ODBC API)以简化客户端和不同DBMS间的互操作。 ODBC驱动为应用提供了连接到数据库的能力，本产品为openLooKeng的ODBC驱动程序，符合ODBC 3.5的核心级（Core Level）一致性规范。 先决条件 使用本产品需要具备以下知识： ANSI结构化查询语言（SQL） ODBC程序员参考文档 支持的版本 本产品支持以下版本: Windows 10 64bit Windows Server 2016 64bit 其他版本的Windows系统未经过严格测试，用户可以自己尝试，本产品不做任何质量保证 openLooKeng ODBC驱动的安装 本手册对应二进制文件分发即msi安装包的安装形式，需要从源码编译安装的开发者请参考开源代码中的Build.md 配置需求 安装本驱动的系统，需要满足如下要求： 请确保系统为如下系统： Windows 10 (64 bit) Windows Server 2016 (64 bit) 请确保安装磁盘具有超过180MB的可用磁盘空间 安装步骤 安装本驱动前请确认当前具有管理员权限。 双击msi安装包，出现安装的欢迎界面，单击“Next”。 第二页为用户协议，勾选接受后单击“Next”。 第三页选择安装方式，建议选择“Complete”完整安装。 第四页选择安装路径，配置后单击“Next”。 完成上述安装设置后在最后一页单击“Install”开始安装。 注意安装过程中会弹出cmd命令行窗口，为安装Driver组件的过程，待其完成后会自动关闭。至此完成了openLooKeng ODBC驱动的全部安装过程
Tableau的Web连接器 Tableau的openLooKeng网络连接器允许用户在Tableau上运行对openLooKeng的查询。该连接器实现Tableau Web连接器API中的函数。 Tableau在创建新的web数据源时，会询问Web连接器的URL。使用以下URL，example.net:8080替换成openLooKeng协调节点的主机名和端口号（默认端口为8080）： http://example.net:8080/tableau/presto-connector.html 当Tableau第一次加载openLooKeng Web连接器时，将呈现一个HTML表单。在这个表单中，你需要填写例如用户名、要查询的目录和架构、数据源名称、要设置的会话参数以及最终要运行的SQL查询等详细信息。点击Submit后，查询将提交给openLooKeng协调节点，Tableau将逐页从协调节点检索的结果中创建摘录。在Tableau摘录完查询的结果之后，你可以使用此摘录进一步分析Tableau。 说明 使用openLooKeng Web连接器，你只能创建Tableau摘录，因为Web连接器API目前不支持实时模式。 Web连接器API只支持openLooKeng中可用的数据类型的一个子集。具体而言，Tableau Web连接器API目前支持以下Tableau数据类型：bool、date、datetime、float、int和string。openLooKeng boolean和date类型将分别转换为Tableau客户端上的Tableau数据类型bool和date。任何其他Presto类型，如array、map、row、double、bigint等，将转换为Tableau string，因为它们未映射到任何Tableau类型。
openLooKeng验证器 openLooKeng验证器可用于针对另一个数据库（如MySQL）测试openLooKeng，或针对彼此测试两个openLooKeng集群。在开发openLooKeng时，我们使用它来针对先前的发行版持续测试主干。使用下表创建MySQL数据库，并通过你想要运行的查询加载该数据库： CREATE TABLE verifier_queries( id INT NOT NULL AUTO_INCREMENT, suite VARCHAR(256) NOT NULL, name VARCHAR(256), test_catalog VARCHAR(256) NOT NULL, test_schema VARCHAR(256) NOT NULL, test_prequeries TEXT, test_query TEXT NOT NULL, test_postqueries TEXT, test_username VARCHAR(256) NOT NULL default 'verifier-test', test_password VARCHAR(256), control_catalog VARCHAR(256) NOT NULL, control_schema VARCHAR(256) NOT NULL, control_prequeries TEXT, control_query TEXT NOT NULL, control_postqueries TEXT, control_username VARCHAR(256) NOT NULL default 'verifier-test', control_password VARCHAR(256), session_properties_json VARCHAR(2048), PRIMARY KEY (id) ); 接下来，创建一个属性文件来配置验证器：
预留关键字 下表列出了openLooKeng中预留的所有关键字，以及它们在SQL标准中的状态。这些预留的关键字必须加引号（使用双引号），以便用作标识符。 关键字 SQL:2016 SQL-92 ALTER 预留 预留 AND 预留 预留 AS 预留 预留 BETWEEN 预留 预留 BY 预留 预留 CASE 预留 预留 CACHE CAST 预留 预留 CONSTRAINT 预留 预留 CREATE 预留 预留 CROSS 预留 预留 CUBE 预留 CURRENT_DATE 预留 预留 CURRENT_PATH 预留 CURRENT_ROLE 预留 预留 CURRENT_TIME 预留 预留 CURRENT_TIMESTAMP 预留 预留 CURRENT_USER 预留 DEALLOCATE 预留 预留 DELETE 预留 预留 DESCRIBE 预留 预留 DISTINCT 预留 预留 DROP 预留 预留 ELSE 预留 预留 END 预留 预留 ESCAPE 预留 预留 EXCEPT 预留 预留 EXECUTE 预留 预留 EXISTS 预留 预留 EXTRACT 预留 预留 FALSE 预留 预留 FOR 预留 预留 FROM 预留 预留 FULL 预留 预留 GROUP 预留 预留 GROUPING 预留 HAVING 预留 预留 IN 预留 预留 INNER 预留 预留 INSERT 预留 预留 INTERSECT 预留 预留 INTO 预留 预留 IS 预留 预留 JOIN 预留 预留 LEFT 预留 预留 LIKE 预留 预留 LOCALTIME 预留 LOCALTIMESTAMP 预留 NATURAL 预留 预留 NORMALIZE 预留 NOT 预留 预留 NULL 预留 预留 ON 预留 预留 OR 预留 预留 ORDER 预留 预留 OUTER 预留 预留 OVERWRITE 预留 PREPARE 预留 预留 RECURSIVE 预留 RIGHT 预留 预留 ROLLUP 预留 SELECT 预留 预留 TABLE 预留 预留 THEN 预留 预留 TRUE 预留 预留 UESCAPE 预留 UNION 预留 预留 UNNEST 预留 UPDATE 预留 USING 预留 预留 VALUES 预留 预留 VACUUM WHEN 预留 预留 WHERE 预留 预留 WITH 预留 预留
数据类型 openLooKeng有一组内置的数据类型，如下所述。可以通过插件提供更多的类型。 注意 连接器不需要支持所有的数据类型。连接器支持的数据类型，请参见连接器文档。 布尔类型 BOOLEAN 捕获布尔值true和false。 整数类型 TINYINT 一个8比特带符号的2补码整数，最小值为-2^7，最大值为2^7 - 1。 SMALLINT 一个16比特带符号的2补码整数，最小值为-2^15，最大值为2^15 - 1。 INTEGER 一个32比特带符号的2补码整数，最小值为-2^31，最大值为2^31 - 1。该类型也被称为INT。 BIGINT 一个64比特带符号的2补码整数，最小值为-2^63，最大值为2^63 - 1。 浮点类型 REAL 一种不精确的可变精度的32比特的数据类型，实现IEEE 754标准定义的二进制浮点运算。 此类型也被称为FLOAT。 例如: REAL ‘10.3’, REAL ‘10.3e0’, REAL ‘1.03e1’ DOUBLE 一种不精确的可变精度的64比特的数据类型，它实现了IEEE 754标准定义的二进制浮点运算。 该类型也被称为DOUBLE PRECISION。 固定精度类型 DECIMAL 固定精度的十进制数。精度最高可达38位，但性能最高可达18位。 该类型也被称为NUMERIC和DEC。 此数据类型有两个参数： precision - 表示总位数。 scale - 小数位数。Scale可选，默认为0。 类型定义示例：DECIMAL(10,3), DECIMAL(20)
从Hive迁移 openLooKeng使用ANSI SQL语法和语义，而Hive使用一种类似SQL的语言HiveQL。 使用下标代替UDF访问数组的动态索引 SQL中的下标运算符支持全表达式，而Hive只支持常量。因此，你可以如下编写查询： SELECT my_array[CARDINALITY(my_array)] as last_element FROM ... 避免越界访问数组 越界访问数组元素将导致异常。你可以使用if通过以下方式避免此情况： SELECT IF(CARDINALITY(my_array) >= 3, my_array[3], NULL) FROM ... 对数组使用ANSI SQL语法 数组的索引从1开始，而不是从0开始： SELECT my_array[1] AS first_element FROM ... 使用ANSI语法构造数组： SELECT ARRAY[1, 2, 3] AS my_array 对标识符和字符串使用ANSI SQL语法 字符串用单引号分隔，标识符用双引号而不是反引号分隔： SELECT name AS "User Name" FROM "7day_active" WHERE name = 'foo' 引用以数字开头的标识符 以数字开头的标识符在ANSI SQL中是不合法的，必须使用双引号括起来： SELECT * FROM "7day_active" 使用标准字符串连接运算符 使用ANSI SQL字符串连接运算符： SELECT a || b || c FROM ... 使用CAST目标的标准类型 CAST目标支持以下标准类型：
总体设计 在openLooKeng中，我们支持加载并运行用户自定义的Hive scalar functions。基本原理是openLooKeng将加载Hive function的元数据，对Hive function在openLooKeng中注册，将evaluate方法的参数从Hive function内部数据类型转换为openLooKeng内部数据类型，然后利用Java reflection动态调用Hive function。 配置 为了加载Hive function，用户应该将Hive function元数据添加到udf.properties，格式为：function_name class_path。一个典型的udf.properties示例，如下所示： booleanudf io.hetu.core.hive.dynamicfunctions.examples.udf.BooleanUDF shortudf io.hetu.core.hive.dynamicfunctions.examples.udf.ShortUDF byteudf io.hetu.core.hive.dynamicfunctions.examples.udf.ByteUDF intudf io.hetu.core.hive.dynamicfunctions.examples.udf.IntUDF 用户应将Hive function函数的jar包和依赖包上传到${node.data-dir}，这个配置在node.properties中。用户可以通过在config.properties中设置external-functions.dir来自定义上传的路径，默认路径是“externalFunctions”。一个示例配置如下： external-functions.dir=externalFunctions 因此，默认情况下，用户应该将其Hive function上传到${node.data-dir}的externalFunctions文件夹。 用户应将Hive function的配置文件udf.properties上传到${node.data-dir}/etc目录下。 异步执行 考虑到系统的安全性，我们提供了一种异步执行hive function的机制。 用户定义的Hive function函数可以通过设置max-function-running-time-enable在另一个线程中执行。默认值为false 用户可以通过设置max-function-running-time-in-second来限制Hive function的最大运行时间。默认值为600s。 用户还可以通过设置function-running-thread-pool-size来限制运行Hive function的线程池大小。默认值为100 上述配置在config.properties的示例配置如下： max-function-running-time-enable=true max-function-running-time-in-second=300 function-running-thread-pool-size=10 注意：由于待查询表的每一行数据可能都会使用Hive function函数，因此如果启用Hive function的异步执行机制可能会导致性能严重下降。 请根据实际场景在安全和性能上进行平衡选择 使用需知 在openLooKeng中，我们目前只支持以下常见的数据类型的Hive function： boolean, byte, short, int, long, float, double Boolean, Byte, Short, Int, Long, Float, Double List<T>, Map<T,V> 目前只支持小于或等于五个参数的Hive函数。如果用户添加了超过五个参数的函数，openLooKeng将忽略该函数并打印错误日志。
SQL迁移工具 SQL迁移工具帮助用户将SQL语法转换为ANSI 2003 的SQL语法。目前仅支持Hive 和 Impala SQL语法。 使用SQL迁移工具 下载hetu-sql-migration-cli-{version number}-executable.jar， 并重命名为 openlk-sql-migration-cli， 可以运行该命令chmod +x让它变成可执行的， 然后运行它。 交互模式 该工具支持交互模式运行。例如： ./openlk-sql-migration-cli --type hive lk:HIVE> lk:HIVE> INSERT INTO TABLE table1 VALUES(10, "NAME"); ==========converted result========== INSERT INTO table1 VALUES ROW (10, 'NAME') =================Success============= 参数名称 描述 --type or -t 输入SQL语句的类型，如hive、impala。可选参数，默认值为hive。 下面是一些常用的命令： 命令 描述 !chtype value 修改当前会话的源sql类型 exit或quit 退出交互模式 history 获得前面的输入语句 help 替换帮助信息 批处理模式
基于成本的优化 openLooKeng支持多种基于成本的优化，如下所述。 Join枚举 在查询中执行join的顺序会对查询的性能产生重大影响。join排序方面对性能影响最大的是网络处理和传输的数据的大小。如果一个产生大量数据的join在早期执行，那么后续的阶段需要处理大量数据的时间将长于需要的时间, 这样会增加查询所需的时间和资源。 使用基于成本的join枚举，openLooKeng使用连接器提供的/optimizer/statistics来评估不同join排序的成本，并自动选择计算成本最低的join排序。 join枚举策略由join_reordering_strategy会话属性控制，其中optimizer.join-reordering-strategy配置属性提供默认值。 有效值如下： AUTOMATIC（默认值） -启用全自动join枚举 ELIMINATE_CROSS_JOINS -消除不必要的交叉join NONE -纯句法join顺序 如果使用AUTOMATIC但没有统计数据，或由于任何其他原因成本无法计算，则改用ELIMINATE_CROSS_JOINS策略。 Join分布选择 openLooKeng使用基于哈希的join算法。这意味着对于每个join操作符，必须从一个join输入（称为构建侧）创建哈希表。然后，迭代另一个输入（探针侧），并查询哈希表以找到匹配的行。 有两种类型的join分布： 分区模式：参与查询的每个节点仅从部分数据构建哈希表 广播模式：参与查询的每个节点从所有数据构建一个哈希表（数据复制到每个节点） 这两种类型各有利弊。分区join要求使用join键的散列重分布这两个表。这使得分区join比广播join慢（有时慢很多），但允许更大的join。特别是，当构建端比探测端小得多时，广播join将更快。但是，广播join要求join的构建端上的表在过滤后适合每个节点上的内存，而分布式join只需要适合所有节点上的分布式内存。 使用基于成本的join分布选择，openLooKeng自动选择使用分区join或广播join。使用基于成本的join枚举，openLooKeng自动选择哪一侧是探针侧，哪一侧是构建侧。 join分发策略由join_distribution_type会话属性控制，其中join-distribution-type配置属性提供默认值。 有效值如下： AUTOMATIC（默认值） -自动为每个join确定join分布类型 BROADCAST -对所有join使用广播join分布 PARTITIONED -对所有join使用分区join分布 动态过滤生成 根据构建测的JoinNode属性选择性的生成有效的动态过滤器。当其为高选择率时，仅生成主要的过滤器。其为低选择率时，则不生成过滤器。 使用基于成本的动态过滤生成，openLooKeng将根据构建测的JoinNode选择率高低来选择性的生成动态过滤。 动态过滤生成由optimize_dynamic_filter_generation会话属性控制启用。 有效值如下： true （默认值）- 启用动态过滤生成 false - 不启用动态过滤生成 连接器实现 为了使openLooKeng优化器使用基于成本的策略，连接器实现必须提供statistics。
EXPLAIN成本 在计划期间，与计划的每个节点相关联的开销将根据查询中的表的表统计信息计算。此计算的成本将作为EXPLAIN语句的输出的一部分打印出来。 在计划树中，成本信息以{rows: XX (XX), cpu: XX, memory: XX, network: XX}格式呈现。rows是指每个计划节点在执行过程中期望输出的行数。行数后面括号中的值表示每个计划节点期望输出的数据大小（以字节为单位）。其他参数表示计划节点执行时预计占用的CPU、内存、网络等资源。这些值并不代表任何实际的单位，而是用于比较计划节点之间的相对成本，使优化器能够选择执行查询的最佳计划。如果其中任何一个值未知，则打印?。 示例： lk:default> EXPLAIN SELECT comment FROM tpch.sf1.nation WHERE nationkey > 3; - Output[comment] => [[comment]] Estimates: {rows: 22 (1.69kB), cpu: 6148.25, memory: 0.00, network: 1734.25} - RemoteExchange[GATHER] => [[comment]] Estimates: {rows: 22 (1.69kB), cpu: 6148.25, memory: 0.00, network: 1734.25} - ScanFilterProject[table = tpch:nation:sf1.0, filterPredicate = ("nationkey" > BIGINT '3')] => [[comment]] Estimates: {rows: 25 (1.94kB), cpu: 2207.00, memory: 0.00, network: 0.
基于规则的优化 openLooKeng支持一种基于规则的优化，如下所述。 Join转换 inner-join相较于semi-join更为高效。 使用基于规则的join转换， openLooKeng自动将包含semi-join的查询转换为等同意义的inner-join。 join转换由rewrite_filtering_semi_join_to_inner_join会话属性控制， 其中optimizer.rewrite-filtering-semi-join-to-inner-join配置属性属性提供默认值。 有效值如下： true - 启用自动转换 false （默认值） - 不启用自动转换 Ranking - TopNRankingNumberNode Ranking查询中使用了TopNRankingNumberNode述语进行了成本优化。 Ranking优化由optimize_top_n_ranking_number会话属性控制启用，其中optimizer.optimize-top-n-ranking-function配置属性提供默认值。 有效值如下： true （默认值）- 启用TopNRankingNumberNode述语 false - 不启用TopNRankingNumberNode述语
表统计 openLooKeng支持基于统计信息的查询优化。为了让查询利用这些优化，openLooKeng必须提供该查询中表的统计信息。 表统计信息由连接器提供给查询计划器。目前仅Hive连接器支持统计。 表格布局 统计信息通过表布局向查询计划器呈现。一个表布局表示表数据的子集，并包含有关该数据的组织属性（例如排序顺序和分桶）的信息。 可用于表的表布局的数量和表布局的详细信息是每个连接器特有的。以Hive连接器为例： 非分区表只有一个表布局，表示表中的所有数据 分区表拥有一系列表布局。每一组要扫描的分区代表一个表布局。openLooKeng将根据查询中的筛选谓词，尝试选择由最少数量的分区组成的表布局。 可用统计 openLooKeng提供以下统计数据： 对于表： row count：表示表布局的总行数。 对于表格中的每一列： data size：表示需要读取的数据大小 nulls fraction：表示空值的部分 distinct value count：表示独特值的个数。 low value：表示列中最小值。 high value：表示列中最大值 可用于特定查询的统计集取决于所使用的连接器，也因表甚至表布局而异。例如，Hive连接器目前不提供数据大小的统计信息。 可以通过openLooKeng SQL接口使用SHOW STATS命令查询表统计信息。Hive连接器，请参考Hive连接器文档了解如何更新表的统计信息。
表下推优化器规则 openLooKeng支持Table下推优化器规则，以改善符合条件的查询延迟。 用户须执行以下命令为SQL查询中的所有表生成stats，以便根据表的大小对连接源重新排序- ANALYZE tableName; User Hint Comment- 用户还可以添加以下格式的特别注释，通过指定表名及其不重复（主键）列名，来利用表下推规则的好处。 /* #distinct@ table1 = col1, col2, ... #*/ 此提示是可选的，因为如果表有相关统计信息， openLookeng可以标识所有不同的列。 以下查询（由TPC-H Benchmark的Query 17修改而来）就是一个满足条件的查询，将外层表推入子查询，从而提升整体查询时延。 Original Query- SELECT Sum(lineitem.extendedprice) / 7.0 AS avg_yearly FROM lineitem, part, ( SELECT 0.2 * Avg(lineitem.quantity) AS s_avg, lineitem.partkey AS s_partkey FROM lineitem GROUP BY lineitem.partkey ) WHERE part.partkey = lineitem.partkey AND part.brand = 'Brand#43' AND part.container = 'LG PACK' AND part.partkey = s_partkey AND lineitem.quantity < s_avg /* #distinct@ part = partkey #*/; 在上述查询中，表part是相关的外部查询表，以partkey为唯一列，与表lineitem连接。下面给出一个等价的重写后的查询语句，将part表推入到子查询。
openLooKeng概念 服务器类型 openLooKeng服务器有两种类型：协调节点和工作节点。下一节将解释这两者的区别。 协调节点 openLooKeng协调节点是负责解析语句、规划查询和管理openLooKeng工作节点的服务器。它是openLooKeng安装的“大脑”，也是客户端连接以提交语句执行的节点。每个openLooKeng安装必须有一个openLooKeng协调节点，以及一个或多个openLooKeng工作节点。对于开发或测试目的，可以配置openLooKeng的单个实例来执行这两个角色。 协调节点跟踪每个工作节点上的活动，并协调查询的执行。协调节点创建了一个查询的逻辑模型，其中包含一系列阶段，然后将其转换为在openLooKeng工作节点集群上运行的一系列相互连接的任务。 协调节点使用REST API与工作节点和客户端进行通信。 工作节点 openLooKeng工作节点是openLooKeng安装中的服务器，负责执行任务和处理数据。工作节点从连接器获取数据，并相互交换中间数据。协调节点负责从工作节点获取结果，并将最终结果返回给客户端。 当openLooKeng工作节点进程启动时，它会将自己通告给协调节点中的发现服务器，这样openLooKeng协调节点就可以使用它来执行任务。 工作节点使用REST API与其他工作节点和openLooKeng协调节点进行通信。 数据来源 在本文档中，你将阅读例如连接器、目录、模式和表之类的术语。这些基本概念涵盖了openLooKeng特定数据源的模型，将在下一节中介绍。 连接器 连接器将openLooKeng适配到如Hive或关系型数据库的数据源。你可以像理解数据库的驱动一样来理解连接器。它是openLooKeng的SPI的一个实现，它允许openLooKeng使用标准API与资源交互。 openLooKeng包含若干内置连接器：JMX连接器、提供对内置系统表访问的系统连接器、Hive连接器以及为TPC-H基准数据服务的TPCH连接器。许多第三方开发人员对连接器做出了贡献，以便openLooKeng可以访问各种数据源中的数据。 每个目录都与一个特定的连接器相关联。如果检查目录配置文件，你将看到每个文件都包含一个强制属性connector.name，目录管理器使用该属性为给定的目录创建连接器。多个目录可以使用同一个连接器来访问类似数据库的两个不同实例。例如，如果有两个Hive集群，你可以在一个openLooKeng集群中配置两个都使用Hive连接器的目录，使你可以从两个Hive集群（甚至在同一个SQL查询中）查询数据。 目录 openLooKeng目录包含模式并通过连接器引用数据源。例如，可以配置一个JMX目录，以便通过JMX连接器访问JMX信息。在openLooKeng中运行SQL语句时，将针对一个或多个目录运行该语句。目录的其他示例包括连接Hive数据源的Hive目录。 在openLooKeng中寻址表时，完全限定的表名称总是以目录作为根。例如，一个完全限定的表名hive.test_data.test将引用hive目录中test_data模式中的test表。 目录定义在openLooKeng配置目录的属性文件中。 模式 模式是组织表的一种形式。目录和模式一起定义了一组可以查询的表。当使用openLooKeng访问Hive或例如MySQL等关系数据库时，模式会在目标数据库中转换为相同的概念。其他类型的连接器可以选择以对基础数据源有意义的方式将表组织到模式中。 表 表是一组无序行，这些行被组织成具有类型的命名列。这与任何关系数据库中的情况相同。源数据到表的映射由连接器定义。 查询执行模型 openLooKeng执行SQL语句，并将这些语句转换为跨协调节点和工作节点分布式集群执行的查询。 语句 openLooKeng执行ANSI兼容的SQL语句。当openLooKeng文档引用一个语句时，既引用ANSI SQL标准中定义的语句。ANSI SQL标准由子句、表达式和谓词组成。 一些读者可能会好奇，为什么本节为语句和查询列出单独的概念。这是必要的，因为在openLooKeng中，语句只是引用SQL语句的文本表示形式。当执行一条语句时，openLooKeng将创建一个查询和一个查询计划，然后该查询计划将分布在一系列openLooKeng工作节点上。 查询 当openLooKeng解析一个语句时，将其转换为一个查询，并创建一个分布式查询计划，该计划随后实现为openLooKeng工作节点上运行的一系列相互连接的阶段。在openLooKeng中检索有关查询的信息时，会收到响应语句生成结果集所涉及的每个组件的快照。 语句和查询之间的区别很简单。可以将语句视为传递给openLooKeng的SQL文本，而查询则是指执行该语句而实例化的配置和组件。查询包含阶段、任务、分片、连接器和其他组件以及协同工作以生成结果的数据源。 阶段 当openLooKeng执行查询时，它将执行分解为多个阶段。例如，如果openLooKeng需要聚合存储在Hive中的10亿行数据，它通过创建一个根阶段来聚合其他几个阶段的输出，这些阶段都设计用于实现分布式查询计划的不同部分。 包含查询的阶段层次结构类似于树。每个查询都有一个根阶段，它负责汇总其他阶段的输出。阶段是协调节点用来为分布式查询计划建模的，但是阶段本身并不在openLooKeng工作节点上运行。 任务 如前一节所述，阶段为分布式查询计划的特定部分建模，但是阶段本身并不在openLooKeng工作节点上执行。要理解一个阶段是如何执行的，需要理解一个阶段是实现为一系列任务，这些任务分布在openLooKeng工作节点的网络上。 在openLooKeng体系结构中，任务是“工作马”，因为分布式查询计划被分解为一系列阶段，这些阶段然后被转换为任务，然后对这些任务作用或处理分片。openLooKeng任务具有输入和输出，就像一个阶段可以由一系列任务并行执行一样，一个任务与一系列驱动并行执行。 分片 分片是一个较大数据集的一部分，任务在分片上执行。分布式查询计划最低级别的阶段通过分片来从连接器检索数据，分布式查询计划较高级别的中间阶段从其他阶段检索数据。 当openLooKeng调度查询时，协调节点将查询连接器，以获得可用于表的所有分片的列表。协调节点跟踪哪些机器正在运行哪些任务，以及由哪些任务处理哪些分片。 驱动 任务包含一个或多个并行驱动。驱动根据数据并结合运算符生成输出，然后输出由一个任务聚合，然后在另一个阶段传递给另一个任务。驱动是一系列操作符实例，或者可以将驱动视为内存中操作符的物理集合。它的并行度在openLooKeng架构中是最低级别。驱动有一个输入和一个输出。 运算符 运算符消费、转换和生产数据。例如，表扫描从连接器获取数据并生成其他运算符可以使用的数据，而过滤运算符通过在输入数据上应用谓词来使用数据并生成子集。 交换 交换在openLooKeng节点之间为查询的不同阶段传递数据。任务将数据生成到输出缓冲区中，并使用交换客户端使用来自其他任务的数据。
用例 跨源异构查询场景 RDBMS（如MySQL、Oracle等）、NoSQL（如HBase、ES、Kafka等）等数据管理系统广泛用于客户的各种应用系统中。随着数据量的增加，数据管理越来越完善，客户逐步基于Hive或MPPDB建立数据仓库。这些数据存储系统往往相互隔离，形成相互独立的数据孤岛。数据分析师经常遇到以下问题： 面对海量数据，如果不知道数据用在哪里，怎么用，就无法基于海量数据构建新的业务模型。 查询不同的数据源，需要不同的连接方式或客户端，运行不同的SQL方言。这些差异导致额外的学习成本和复杂的应用开发逻辑。 如果数据没有聚合，则无法对不同系统的数据执行联合查询。 可以使用openLooKeng实现RDBMS、NoSQL、Hive、MPPDB等数据仓库的联合查询。利用openLooKeng的跨源异构查询能力，数据分析师可以快速分析海量数据。 跨域跨DC查询 在二级或多级数据中心场景中，例如省-市数据中心或总部-分部数据中心，用户经常需要从省（总部）数据中心或市（分部）数据中心查询数据。跨域查询的瓶颈是多个数据中心之间的网络问题（例如带宽不足、高时延、丢包等）。因此，查询时延高，性能不稳定。openLooKeng是专为跨域查询设计的跨域跨DC解决方案。openLooKeng集群部署在多个DC中。DC2中的openLooKeng集群完成计算后，通过网络将结果传递给DC1中的openLooKeng集群，在DC1中的openLooKeng集群完成聚合计算。在openLooKeng跨域跨DC方案中，计算结果在openLooKeng集群之间传递。这避免了网络带宽不足和丢包带来的网络问题，在一定程度上解决了跨域查询的问题。 存储计算分离 openLooKeng本身没有存储引擎，但可以查询存储在不同数据源中的数据。因此，该系统是一个典型的存储计算分离系统，有利于独立扩展计算和存储系统。openLooKeng存储计算分离架构适用于动态扩展集群，实现资源快速弹性伸缩。 快速数据探索 客户拥有大量数据。为了使用这些数据，他们通常会构建专用的数据仓库。但是，这将带来额外的数据仓库维护人力成本和数据ETL时间成本。对于需要快速探索数据，但又不想建设专用数据仓库的客户，复制数据并加载到数据仓库费时费力。openLooKeng可以使用标准SQL定义一个虚拟数据市场，通过跨源异构查询能力连接各个数据源。这样，在虚拟数据市场的语义层中就可以定义出用户需要探索的各种分析任务。借助openLooKeng的数据虚拟化能力，客户可以快速构建基于多种数据源的探索分析服务，无需建设复杂、专用的数据仓库。
Join查询的支持 StarTree Cube也可以帮助优化对join查询的聚合。优化器在逻辑计划中寻找聚合子树结构，通常如下所示。 AggregationNode |- ProjectNode[Optional] . |- ProjectNode[Optional] . . |- FilterNode[Optional] . . . |- JoinNode . . . . [More Joins] . . . . . . . . . |- ProjectNode[Optional] - Left . . . . . |- TableScanNode [Fact Table] . . . . |- ProjectNode[Optional] - Right . . . . . |- TableScanNode [Dim Table] 如果确认查询与结构匹配，优化器会通过将Fact TableScanNode替换为Cube TableScanNode来重写逻辑计划。这类似于单表重写。 Star架构的支持 Join查询优化器仅支持Star架构。Star架构是一种数据仓库架构模型，其中一个事实表引用多个维度表，从图表上看，它看起来像一个星形，事实表位于中心，维度表从它向外辐射。支持各种连接。 Cube管理 Create Cube仍可用于定义Cubes以优化Join查询。困难的部分是在构建多维数据集时识别GROUP构造。对于单表查询，GROUP BY子句将只包含来自同一个表的列。但是对于连接查询，尤其是Star架构查询，GROUP BY包含来自Dimension表而不是Fact表的列。 让我们通过以下查询进行更多分析。
StarTree多维数据集 介绍 StarTree Cube，作为多维数据集，是存储为表格的物化预聚合结果。该技术旨在优化低延迟冰山查询。 冰山查询是涉及GROUP BY和HAVING子句的SQL查询的一种特殊情况，其中答案集相对于扫描的数据大小而言较小。 查询的特点是输入量大，输出量小。 此技术允许用户在现有表上构建Cubes，其中包含旨在优化特定查询的聚合和维度。 Cubes是汇总预聚合，与原始表相比，其维度和行数更少。 较少的行数意味着花费在表扫描上的时间显着减少，从而减少查询延迟。 如果查询是预聚合表的维度和度量的子集， 那么Cube可以用来计算查询，而无需访问原始表。 Cube有以下几个属性 Cubes以表格格式存储 一般来说，可以为任何连接器中的任何表创建Cubes并存储在另一个连接器中 通过重写逻辑计划以使用Cube而不是原始表来减少查询延迟。 Cube的多维数据集优化器规则 作为逻辑计划优化的一部分，Cube优化器规则使用Cubes分析和优化逻辑计划的聚合子树。 该规则查找通常如下所示的聚合子树 AggregationNode |- ProjectNode[Optional] |- ProjectNode[Optional] |- FilterNode[Optional] |- ProjectNode[Optional] |- TableScanNode 规则通过子树解析，识别出与Cube元数据匹配的表名、聚合函数、where子句、group by子句 识别任何可以帮助优化查询的Cube。在多个匹配的情况下，选择最近创建的Cube进行优化。如果找到任何匹配项，则整个 使用Cube重写聚合子树。此优化器使用TupleDomain构造来匹配查询中提供的谓词是否可以被 立方体。 下图描绘了优化后逻辑计划的变化。 推荐用法 Cubes对于需要大量输入并产生少量输入的冰山查询最有用。 当Cube的大小小于构建Cube的实际表上的大小时，查询性能最佳。 如果源表更新，则需要重建Cubes。 注意： 如果在构建Cubes后更新源表，Cube优化器将忽略在表上创建的Cubes。原因是，对更新的任何操作都被视为对现有数据的更改，即使在原始表中只插入了新行。由于无法区分插入和更新，因此不能使用多维数据集，因为它可能会导致不正确的结果。我们正在研究解决此限制的解决方案。 支持的连接器 以下是用于存储Cube的支持的连接器 Hive Memory 以下连接器中的表可用作构建StarTree Cube Hive Memory Clickhouse 未来的工作 支持更多JDBC连接器 简化Cube管理 2.1. 克服为更大的数据集创建Cube的限制。 启用和禁用StarTree Cube 启用：
用法 可以使用任何受支持的客户端管理Cubes，例如位于安装中bin目录下的hetu-cli。 CREATE CUBE 概要 CREATE CUBE [ IF NOT EXISTS ] cube_name ON table_name WITH ( AGGREGATIONS = ( expression [, ...] ), GROUP = ( column_name [, ...]) [, FILTER = (expression)] [, ( property_name = expression [, ...] ) ] ) [WHERE predicate] 描述 使用指定的组和聚合创建一个新的空Cube。使用INSERT INTO CUBE (see below)来插入数据。 如果Cube已经存在，可选的IF NOT EXISTS子句会导致错误被抑制。 可选的property_name部分可用于在新创建的Cube上设置属性。 要列出所有可用的表属性，请运行以下查询： SELECT * FROM system.metadata.table_properties 注意： 这些属性仅限于为其创建Cube的连接器。 例子 在orders上创建一个新的Cubeorders_cube： CREATE CUBE orders_cube ON orders WITH ( AGGREGATIONS = ( SUM(totalprice), AVG(totalprice) ), GROUP = ( orderstatus, orderdate ), format = 'ORC' ) 创建一个新的分区Cubeorders_cube：
Release 0.1.0 (2020年6月30日) 关键特性 特性 描述 Adaptive Dynamic Filter 动态特性增强，除了bloom filter外，还可以使用hashsets存储build侧值，用于过滤探针侧。筛选器存储在分布式内存存储中，以便后续查询可以重用它们，而不必重新构建。 Dynamically Add Catalog 添加目录REST api允许管理员在运行时添加任何连接器的新目录。目录属性文件被写入一个共享存储区，在那里它们被openLooKeng集群节点发现并注册和加载。使用该方法不需要重启集群。 Cross Region Dynamic Filter 跨数据中心场景，当探针侧在远端数据中心，构建侧在本地数据中心时，自适应过滤器会创建一个bloom filter。数据中心连接器增强，通过网络将bloom filter发送到远程数据中心，在远程数据中心中，它可用于筛选探针端。这减少了需要通过网络从远程数据中心传输到本地数据中心的数据量。 Horizontal Scaling Support 新增隔离节点和隔离节点状态，缩容时可静默节点。ISOLATED节点不接受任何新任务。 VDM 虚拟数据集市，允许管理员创建虚拟目录和虚拟方案。在虚拟模式中，管理员可以在跨多个数据源的表上创建视图。虚拟数据集市简化了跨数据源和跨区域的表访问。 IUD support for ORC 支持Hive ORC表上的事务性插入、更新、删除。 仅支持Hive 版本3.x. Compaction for ORC 支持hive ORC事务表的Compaction，通过增加每个读取器的数据获取来减少读取的文件数量，从而有助于提高查询性能，并提高并发度 CarbonData Connector with IUD support 支持CarbonData表的插入、更新、删除操作 Insert Overwrite 支持插入覆盖语法。这是裁剪和加载到现有表的简单方法 ODBC connector ODBC PowerBI、Tableau、永洪桌面等第三方BI工具连接openLooKeng的驱动和网关 Dynamic Hive UDF 将自定义的Hive UDF动态加载到openLooKeng HBase Connector HBase连接器支持查询HBase数据源的数据 Enhance Create table statement 允许在openLooKeng中执行CREATE TABLE AS命令时指定所管理的hive表的外部位置;允许在openLooKeng中创建Hive事务表 Metadata Cache 引入通用元数据缓存SPI，为任何连接器提供透明的缓存层。如果缓存不存在，则元数据缓存委托连接器特定的元数据。目前JDBC连接器、DC连接器 Cross DC Connector 新的连接器被引入，以支持跨广域网的响应查询，允许客户端查询位于物理上遥远的另一个数据中心的数据源。 High Availability (Active-Active) 支持HA AA模式，将运行时状态信息存储在Hazelcast等分布式缓存中。黑兹尔卡斯特集群的形成是使用种子文件完成的。发现服务、OOM、CPU使用率使用分布式锁，以确保只有一个协调器启动这些服务。 Sql Migration Tool 协助Hive SQL迁移到openLooKeng兼容SQL的补充工具 代码增强 RawSlice Optimization:通过重用RawSlice对象，而不是构造新的Slice对象，减少openLooKeng的内存占用。Implicit Conversion ：支持数据类型隐式转换。例如：如果Insert语句中的查询类型与表类型不匹配，则可以将查询类型隐式转换为表类型。 获取文档 请参考：https://gitee.
Release 1.0.0 (2020年9月23日) 关键特性 该版本主要在三个主要领域进行了改进：性能、安全性和可用性。 性能 对引擎进行了新的性能特性增强，以进一步提高即席交互式查询的性能。这些增强包括：增强动态过滤器以使用更高效的bloom过滤器实现；以及优化动态过滤器的收集侧算子，以便能够尽快收集和应用动态过滤器。其他性能优化还包括引入谓词下推以允许OR谓词被推送到ORC读取器，以及启发式索引支持OR谓词对分片进行过滤。最后，为了减少插入和更新操作后ORC文件的数量，引入了ORC文件的自动压缩功能。 安全性 在本版本中，社区聚焦在进一步强化引擎的安全性。代码中解决了多个漏洞，并引入了审计日志。此外，还引入了一个新的功能，允许管理员对Catalog配置文件的敏感信息进行加密处理，比如数据源凭据。 可用性 可用性是本发行版的另一个重点关注的领域。为了提供数据库般的用户体验，社区引入了SQL迁移工具，该工具帮助将SQL语句从其他引擎迁移到openLooKeng中。其他可用性增强包括通过JMX监控ORC缓存的各项指标，以便管理员查看索引及数据缓存命中率；以及改进CACHE sql命令，以便为数据缓存提供更大的灵活性。此外，还对安装和部署脚本进行了更改，以支持包含ARM和x86节点的混合部署，并引入了新的脚本允许管理员基于容器部署openLooKeng服务。 详细特性描述见下表。 类别 特性 PR #s 安全 新增审计日志功能。 160 安全漏洞修复。 113 处理CVEs问题。 144 安装部署 新增安装脚本支持基于Docker & Kubernetes部署和运行openLooKeng。 50 支持在ARM 和. x86混合架构上部署openLooKeng。 5 工具 提供工具支持将Impala SQL迁移到ANSI SQL。 52 SQL迁移工具的易用性增强，帮助用户轻松识别SQL语句之间的差异，并接受更改。 159 ODBC Driver 支持openLooKeng复杂数据类型，如ARRAY、JSON、MAP、ROW等。 11 （hetu-odbc-gateway的repo） & 6 （hetu-odbc-driver的 repo） 支持双向滚动游标，以便于对表和结果集进行更简单的迭代。也支持设置游标到指定位置。 10 启发式索引 重构启发式索引，使其成为openLooKeng的一个插件，并使用HetuFileSystem Client。 40 添加额外的配置，让管理员更好地控制索引缓存。例如，管理员现在可以设置索引缓存可以占用的最大内存。 85 支持在执行计划阶段对包含OR谓词的查询进行分片过滤。 93 增加会话属性，能够在服务运行时禁用启发式索引。 126 优化器 将OR等谓词推送到ORC读取器中，以实现数据过滤。 103 执行流水线 几个动态过滤器增强特性，如使用内部布隆过滤器提供更好的性能，以及改进的行过滤逻辑，以及添加状态存储监听器以收集新合并的动态过滤器。 65、86、100、112、137 增强动态过滤并支持更多的底层block类型，启用block的行过滤，利用java向量化加速。 101、117 ORC IUD/ACID 支持基于阈值的数据压缩自动触发和处理，当对表进行修改操作时，无需用户干预数据压缩，并且查询性能不下降。（目前仅支持Hive） 141 数据压缩操作后自动清理ORC文件。 89 Catalog 管理 对catalog配置文件中的敏感信息进行信息加密，比如密码。 170 DC Connector 支持元数据和执行计划缓存，以提升DC Connector的性能。 128 ORC数据缓存 通过JMX监控ORC缓存的各项指标。 33、142 CACHE sql命令的可用性增强，为选择缓存哪些分区提供了更大的灵活性。 90、99 获取文档 请参考：https://gitee.
Release 1.0.1 (2020年9月30日) 关键特性 本次发布主要修复了版本号问题和Index-cli的问题。 此外，还在安全方面做了更多增强。 类别 特性 PR #s 索引 将Index cli合并到hetu-cli中，并为index的命令引入基本的权限控制 283, 298 安全 处理CVEs问题 289,287,295,288,285,292,297,249,302 获取文档 请参考：https://gitee.com/openlookeng/hetu-core/tree/1.0.1/hetu-docs/zh
Release 1.1.0 (2020年12月30日) 关键特性 分类 特性 PR #s 启发式索引 Btree索引-BTree索用于Split过滤，并且只能使用在Coordinator节点上，如果对作为查询谓词一部分的某一列创建索引，那么openLooKeng可以在执行的过程中通过索引来过滤掉Split，从而提高查询性能。 392,437,452,457 Bitmap索引-Bitmap索引用于读取ORC文件时过滤数据，并且只能使用在Worker节点上。Bitmap索引必须在高基数的列上创建。在这个发布版本中，对Bitmap索引进行了增强，将关键字存储在一个BTree中来加快关键字的查找，索引的创建以及减少索引的大小。 437,418,435,407,390 高性能 五个性能提升的特性：· 窗口函数的性能提升；· 将动态过滤等待时间修改为基于在Worker上的任务调度时间，而不包含花费在计划的时间；· 在Semi-join上使用动态过滤；· 实现Left-join转换成Semi-join的优化规则；· 实现Self-join转换成Group-by的优化规则。 429,366,385,406,391,330,446,382 很多的小Split会影响openLooKeng的查询性能，因为需要对这些Split进行调度，这样会导致更多的调度开销，完成的任务更少，并且每个Split的等待被读取的时间也会增加，为避免这种情况，使用合并小Split特性将小Split组合在一起，作为单个Split一起调度。 387 交换复用特性引入了一个查询优化器，在一次查询中，一个表的数据被这条语句中的多个投影或过滤多次使用时，该特性会在内存中缓存该表数据来降低查询时间。 443 连接器 新增支持openGauss 数据源 492 新增支持MongoDB 数据源 464 重构ElasticSearch 连接器以兼容7.x版本 380 新增Oracle连接器文档，并支持Oracle同义词特性。 380,487 增强Hive 连接器以支持用户透传（impersonation） 454 ODBC语法兼容性能力增强 15,10,19,12,21,22 DC 连接器 跨DC场景下动态过滤下推特性增强 402,419 用户体验 提供全新的WEB UI， 包含在线SQL编辑器和系统状态监控 163,368,404 简化配置项 397,369,449 安全 支持与Apache Ranger 集成以实现统一的权限控制 491 已知问题 分类 描述 Gitee问题 DC连接器 分层的数据中心模型中，分层大于3层，开启动态过滤的耗时可能会比关闭动态过滤的耗时更长，由于过滤的列不是高基数的，会导致过滤效果变差，所以需要引入更高效的过滤器。 I2BAZZ 启发式索引 当删除index的时候，原HDFS上的文件夹并没有被删除，但里面的文件被删除。 I2BB1N 创建Index 并使用谓词‘or’ 时，显示的错误信息与实际功能不一致。这是因为缓存失效了，并且所有的Catalog、Schema、Table、Column信息被重新刷新导致。 I2BB3O 对事务分区表创建BTree索引后，不能过滤Split。 I2BB6M WEB UI 点击刷新按钮后需要元数据树的相应时间很长。 I2BB2B 如果有很多计划信息，文字会溢出文字区域。 I2BB4E 安装 使用自动部署脚本，系统会使用旧的配置，没有任何提示，这样会误导用户。 I2BB52 Vacuum 如果对已执行删除/更新操作的表多次运行vacuum操作，则统计信息可能会被损坏，并导致查询将失败。为了避免这种情况，请在运行vaccum命令前将会话标志hive.
Release 1.2.0 (2021年3月31日) 关键特性 分类 特性 PR #s 启发式索引 针对启发式索引做了如下增强：1. 可以通过配置实现索引的预加载2. 当索引创建失败时，可以清理残留的索引记录。（之前版本，部分记录可能会残留，需要手动清理）3. 动态确定索引创建级别（之前版本，对于BtreeIndex用户必须指定level=table或level=partition，现在不再需要）4. 使用HetuMetastore进行索引元数据管理（删除基于文件的元数据管理）5. BTreeIndex：重构和支持AND、OR运算符6. BitmapIndex：支持其他运算符（>、>=、<、<=、IN、Between，请参见文档了解完整列表）7. 通过TestPrestoServer改进功能自动化测试 646,627,604,537,609,601,529,611,600 Star Tree索引 提供一种预聚合技术，可以优化冰山查询的延迟。1. 提供SQL 以管理Cubes（多维数据集）2. 支持创建分区Cubes3. 谓词支持为部分数据创建Cubes4. 针对构建大型Cubes, 支持增量插入 330 性能 针对CTE（具有with的语句）进行执行计划优化，使得CTE只被执行一次，并将其流式传输到查询中的其他引用，从而减少该查询所需的计算资源。减少计算资源有助于提高系统的总体并发。 623 部分代码和工程化的优化，从而提高数据修改操作的性能 614,625,645 Task Recovery 支持查询任务重试，当查询任务或者工作节点出现错误导致的查询失败时：1. 在查询执行期间捕获快照2. 检测到可恢复故障时，从最近成功的快照恢复查询执行此功能目前还存在使用上的局限性。请参考相关文档 “管理-可靠查询执行”。当检测到不支持的场景时，会生成警告，并自动关闭该功能。目前该功能还是一个beta 版本，不建议在生产环境中使用。下方表格中列出了一些已知问题。 663 连接器 HBase性能优化。针对单表查询性能的提升，我们新增了分片算法。另外，该优化支持 HBase 访问Snapshot的模式，从而提升多并发查询性能。 522,573 支持外部函数（UDF）的注册，也支持将其下推到JDBC数据源。为了让大家拥有更好的体验，用户可以在不迁移自己数据源UDF的情况下，使用已有的UDF, 提高UDF的复用度，使用上更加方便。 647 提供全新的算子下推框架，让算子下推过程更加简单灵活和高效。我们希望每个Connector可以参与到执行计划优化中。即引擎在进行执行计划优化时，能够自行应用Connector的优化规则。 633 Web UI 1、元数据树修改为异步加载，优化定时全量加载导致的UI页面卡顿；2、优化显示问题，查询历史、查询结果分页显示；3、新增连接器的参数配置方式优化，无需自定义配置文件；4、增加节点状态显示； 575,621,641,679 安全 1.
Release 1.3.0 (2021年6月30日) 关键特性 分类 描述 PR #s Task Recovery Task recovery 功能上没有变化，修复了bug，增强了功能的稳定性。兼容spill-to-disk特性。 812,813,837,838,842,843,847,863,868,874,875,885,889,891,901,906,917,930,932 CTE (公共表表达式) 在1.2.0 CTE的基础上进行额外优化。增加了基于成本的决策，以决定是否启用CTE。支持将动态过滤器和谓词下推到CTE节点。 722,811,815,876,921,927 DM (数据管理) 进一步改进了DM（Data Management）操作的性能。提供性能调优参数： - metastore -client-service-threads: 通过使用多个客户端发送/接收请求，支持并发操作Hive Metastore。- metastore -write-bach-size: 打包每次调用包含的多个操作对象，减少Hive metastore之间的数据往来耗时。 888 Star Tree 索引 1. Star Tree Cube现在支持高达10 Billion基数。 2. 更新openLooKeng CLI，以改善cube管理体验。用户可以发单个sql语句来创建和填充cube数据集中的数据，而不是多个sql语句。CLI的优化有助于避免查询超出群集内存限制的问题。3. 问题修复: a. 将连续范围合并为单个范围，以便可以利用Cube b. Count distinct问题–在Cube插入过程中支持过滤源数据。 834,867,890,902,907 CBO 支持排序聚合器（Sorted Source Aggregator）在输入源为预先排好序的情况下，增加了对排序聚合器的支持。这样相比哈希聚合器能够减少大量内存使用，并可以在部分聚合阶段（partial aggregation stage）确定大部分的计算结果，从而减少下一个计划阶段的最终聚合负载。openLooKeng优化器会根据给定查询的代价估计值（CBO），在排序聚合器（Sort Aggregator）和哈希聚合器（Hash Aggregator）之间进行选择。 855,905,906 Hudi 连接器 支持Hudi COW数据表的快照查询; 支持Hudi MOR数据表的快照查询和读优化查询。 881,900 GreenPlum 连接器 支持对GreenPlum数据源的基本读和写操作。不支持删除和更新。 689 Oracle 连接器 Oracle连接器支持Update、Delete操作。 897 ClickHouse 连接器 支持对ClickHouse数据源的基本读和写操作。支持SQL query pushdown 和 external Functions 的注册和下推能力。 920 JDBC 连接器 单表查询支持多分片，通过提高并发来提升性能。 939 Hive 连接器 Hive Connector 的Hive 依赖包从3.
Release 1.4.0 关键特性 分类 描述 Star Tree 1. 更新APIs支持jdbc 连接器使用cube2. 支持Clickhouse连接器使用cube，其它jdbc connector在将来支持3. 问题修复 启发式索引 1. 支持UPDATE INDEX（详细见文档）2. SHOW INDEX中增加index大小，内存和磁盘占用信息3. Bloom index增加nmap cache来减少内存使用（默认打开，详细见文档）4. 支持DROP TABLE同时删除index5. 支持创建index后自动加载index（默认打开，详细见文档） Memory 连接器 修复了几个重要的错误，以解决大型数据集和特定运算符偶尔发生的错误结果 Task Recovery 修复了几个重要的错误，以解决高并发和worker节点故障期间偶尔发生的数据不一致问题 Yarn上部署openLooKeng 支持Yarn上部署openLooKeng集群。当前支持部署单coordinator和多worker节点部署 低时延 1. 优化不包含join的点查sql的stats计算，加快低时延查询的速度2. 新增自适应分片分组，提升高并发查询吞吐量3. 支持非等式动态筛选器，以加快具有<、>、<= & >=等谓词的查询速度 Kylin 连接器 支持对kylin数据源的读操作 已知问题 分类 描述 Gitee问题 Task Recovery 并发CTAS，部分sql报错：“HiveSplitSource is already closed” 144QYL CTA创建事务表，插入数据报错“Unsuccessful query retry” I44RQJ Yarn上部署openLooKeng 启动多个openLooKeng小集群，containers会在相同的节点上启动，导致此节点资源会用完，新启openLooKeng集群失败（实际其它节点还有资源） I4BP5A 启动多个openLooKeng集群，部分集群进CLI报错 I4BY6Z 获取文档 请参考： https://gitee.
Release 1.4.1 (2021年11月12日) 关键特性 本次发布主要新增了OmniData Connector的介绍和ARM架构下支持JDK8。 类别 特性 PR #s 数据源 openLooKeng支持通过OmniData Connector将算子卸载到近数据侧执行，减少无效数据在网络上的传输，有效提升大数据计算性能。 1219 ARM架构 消除因JDK卡顿问题导致ARM架构下对java版本的强制要求，支持ARM架构下使用jdk1.8.262及以上版本。 1214 获取文档 请参考：https://gitee.com/openlookeng/hetu-core/tree/1.4.1/hetu-docs/zh
Release 1.5.0 关键特性 分类 描述 Star Tree 1. 支持优化连接查询，如星型模型的查询。2. 优化查询计划：由于Cube已经包含了汇总结果，所以改写查询计划将聚合运算结果重定向到Cube结果。当group by子句完全与Cube组匹配时性能收益明显。3. 问题修复，以进一步增强Cube的可用性和健壮性。 Memory 连接器 1. 通过增加对内存表分区的支持，允许跳过整个分区的数据，从而提高内存连接器的性能。2. 收集内存表的统计信息，以支持基于openLooKeng代价的优化器。 Task Recovery 修复了几个重要的错误，以解决数据不一致问题，以及在高并发和工作节点故障期间偶尔发生的查询挂起问题。 Yarn上部署openLooKeng 支持在yarn上部署启用HA的openLooKeng集群实例，该实例包含一个反向代理（默认为nginx）和2个或更多协调节点。通过增加和移除yarn容器，实现手动水平缩放openLooKeng集群。 数据持久化 优化了数据溢出到磁盘的机制，将序列化页面直接写入磁盘，而不是缓存。这样，算子可以释放更多内存，相比之前性能提高30% 已知问题 分类 描述 Gitee问题 Task Recovery 在执行CTAS创建表stage1阶段，kill掉一个worker节点，偶现表数据减少 I4M2LW Memory 连接器 查询带index_columns参数创建的表时，报错：java.lang.NullPointerException I4NVW3 删除分区列为double类型表后，重新创建相同表，count(*)查询结果行数增加。 I4LUDF 获取文档 请参考： https://gitee.
Release 1.6.0 关键特性 分类 描述 Star Tree 支持cube更新命令,允许管理员在基础数据更改时轻松更新现有cube的内容 Bloom Index 优化布隆过滤器索引大小使缩小十倍以上 Task Recovery 1. 优化执行失败检测时间：当前需要300秒来确定任务失败,然后继续运行。改进这一点将改善执行流程和整体查询时间 2. 快照时间和大小优化：当执行过程中使用快照时,当前直接使用Java序列化,速度很慢,而且需要更多的空间。使用kryo序列化方式可以减小文件大小并提升速度来增加总吞吐量 数据持久化 1. 优化计算过程数据下盘速度和大小：当在Hash Aggregation（聚合算法）和GroupBy（分组）算子执行过程中发生溢出时,序列化到磁盘的数据会很慢,而且大小也会更大。因此可以通过减小大小和提高写入速度来提高整体性能。通过使用kryo序列化可以提高速度并减小溢出写盘文件大小2. 支持溢出到hdfs上：目前计算过程数据可以溢出到多个磁盘,现在支持溢出到hdfs以提高吞吐量3. 异步溢出/不溢出机制：当可操作内存超过阈值并触发溢出时,会阻塞接受来自下游运算符的数据。接受数据并加入到现有溢出流程将有助于更快地完成任务4. 支持右外连接&全连接场景下的溢出写盘：当连接类型为右外连接或全连接时,不会溢出构建侧数据,因为需要所有数据在内存中进行查找。当数据量较大时,这将导致内存溢出。因此，通过启用溢出机制并创建一个布隆过滤器来识别溢出的数据,并在与探查侧连接期间使用它 连接器增强 增强PostgreSQL和openGauss连接器，支持对数据源进行数据更新和删除操作 已知问题 分类 描述 Gitee问题 Task Recovery 启用快照时，执行带事务的CTAS语句时，SQL语句执行报错 I502KF 启用快照并将exchange.is-timeout-failure-detection-enabled关闭时，概率性出现错误 I4Y3TQ Star Tree 在内存连接器中，启用star tree功能后，查询时偶尔出现数据不一致 I4QQUB 当同时对10个不同的cube执行reload cube命令时，部分cube无法重新加载 I4VSVJ 获取文档 请参考： https://gitee.
Release 1.6.1 (2022年04月27日) 关键特性 本次发布主要是一些SPI的修改和增强，为扩展更多的场景使用。 类别 特性 PR #s 数据源统计信息 增加统计信息获取方式，支持从Connector直接获取统计信息。有些算子可以下推到Connector里面进行计算，可能需要直接从Connector获取统计信息才能展示真正被处理的数据量。 1450 算子处理扩展 增加通过用户自定义worker结点物理执行计划的生成，用户可以实现自己的算子pipeline代替原生实现，加速算子处理。 1436 HIVE UDF扩展 增加 HIVE UDF 函数命名空间的适配，以支持执行基于HIVE UDF框架编写的UDF（含GenericUDF）。 1456 获取文档 请参考：https://gitee.com/openlookeng/hetu-core/tree/1.6.1/hetu-docs/zh
Release 1.7.0 关键特性 分类 描述 算子处理扩展 增加通过用户自定义worker结点物理执行计划的生成，用户可以实现自己的算子pipeline代替原生实现，加速算子处理 Task Recovery 1. 支持不开启快照特性时，实现失败任务重试 2. 支持在CLI端调试模式下显示快照相关统计信息：包括正在捕获的快照数量、已经捕获的快照数量、恢复次数（包括查询重启）、捕获的所有快照大小和捕获快照所需时间、用于恢复的快照大小和恢复时间 3. 资源管理：在任务消耗大量内存导致内存不足时自动暂停/恢复任务，用户也可以选择主动暂停和恢复任务（限于CTAS和INSERT INTO SELECT场景） 4. 增加可配置的失败重试策略：① 超时重试策略 ② 最大次数重试策略 5. 新增Gossip失败检测机制：控制节点通过定期接收心跳来监控工作节点是否存活，Gossip机制使得所有工作节点能够相互监测，确保所有节点所知的信息都是一致的，可以防止在集群中出现短暂网络故障时导致过早的查询失败 openLooKeng WEB UI增强 1. openLooKeng审计日志功能增强2. openLooKeng SQL历史记录持久化 3. SQL Editor支持自动联想 4. 支持常用SQL语句收藏 5. 数据源加载异常时，前端可通过异常标记显示 6. UI支持显示数据源信息 openLooKeng集群管理平台 1. 提供图形化的指标监控及定制，及时获取系统的关键信息 2. 提供服务属性的配置管理，满足实际业务的性能需求 3. 提供集群、服务、实例的操作功能，满足一键启停等操作需求 4. 提供openLooKeng在线部署功能，支持在线升级 5. 提供节点伸缩服务 6. 集成openLooKeng现有的Web UI 7. openLooKeng Manager工具支持用户登录/退出功能 已知问题 分类 描述 Gitee问题 Task Recovery 启用快照时，执行带事务的CTAS语句时，中断一个worker服务，SQL语句执行报错 I5EAM3 获取文档 请参考： https://gitee.
Release 1.8.0 关键特性 分类 描述 任务级恢复 1. 通过使用物化的exchange信息仅重试失败的任务来实现查询恢复，支持Select场景的任务重试和恢复 2. 用于任务恢复的快照文件支持存放在HDFS上 3. 在实现物化exchange数据时，支持直接序列化和压缩。 查询资源管理 实现查询级别的资源监控，当任务超出资源组配置时，可支持任务的自动暂停/恢复、溢出可撤销内存、限制调度和终止查询。 连接器扩展 singleData连接器为openGauss补充OLAP能力，增强数据分析竞争力。支持对接ShardingSphere和tidRange两种模式。 获取文档 请参考： https://gitee.com/openlookeng/hetu-core/tree/1.8.0/hetu-docs/zh
Release 1.9.0 关键特性 分类 描述 任务级恢复 支持Create Table As Select场景的任务重试和恢复 连接器扩展 1. 新增Iceberg连接器，支持数据增删改查，分区演化，历史版本查询，事务，小文件合并 2. 增强Elastic Search连接器，支持算子下推，当前支持下推AND、OR、算术、比较运算符、BETWEEN、IN、GROUP BY、COUNT和SUM 性能增强 1. CTE优化，包括执行管道的重用，CTE结果的物化和重用 2. 执行计划优化，包括使用准确的分区，自适应聚合，join场景的选择率估计和使用能更好过滤的执行策略 获取文档 请参考： https://gitee.com/openlookeng/hetu-core/tree/1.9.0/hetu-docs/zh
节点资源 GET /v1/node 返回openLooKeng服务器已知的节点列表。此调用不需要标头的查询参数，它只返回一个数组，数组中包含openLooKeng安装中的每个已知节点。 响应消息中，recentRequests、recentFailures和recentSuccesses的取值是随时间指数衰减的计数器，衰减参数为1分钟。这个衰减率意味着，如果一个openLooKeng节点在几秒内有1000次成功，那么这个统计值在一分钟内就会下降到367次。 age显示一个节点的运行时长，uri指向该节点的HTTP服务器。最后一次请求和响应时间显示了一个节点的最近使用情况。 下面的响应示例显示一个未经历了任何故障条件的节点。各节点同时上报流量正常、故障等统计数据。 响应样例： HTTP/1.1 200 OK Vary: Accept Content-Type: text/javascript [ { "uri":"http://192.168.1.1:8080", "recentRequests":25.181940555111073, "recentFailures":0.0, "recentSuccesses":25.195472984170983, "lastRequestTime":"2013-12-22T13:32:44.673-05:00", "lastResponseTime":"2013-12-22T13:32:44.677-05:00", "age":"14155.28ms", "recentFailureRatio":0.0, "recentFailuresByType":{} } ] 如果一个节点发生故障，您会看到如下所示的响应。此例中，一个节点发生了一连串的错误。recentFailuresByType字段列出了节点上发生的Java异常。 错误响应样例： HTTP/1.1 200 OK Vary: Accept Content-Type: text/javascript [ { "age": "4.45m", "lastFailureInfo": { "message": "Connect Timeout", "stack": [ "org.eclipse.jetty.io.ManagedSelector$ConnectTimeout.run(ManagedSelector.java:683)", .... "java.lang.Thread.run(Thread.java:745)" ], "suppressed": [], "type": "java.net.SocketTimeoutException" }, "lastRequestTime": "2017-08-05T11:53:00.
查询资源 Query REST服务是rest服务中最复杂的。它包含节点的详细信息，以及其它在openLooKeng上执行的查询的状态和历史的详细信息。 GET /v1/query 此服务返回有关当前在openLooKeng协调节点上执行的查询的信息和统计信息。 当你将浏览器指向一个openLooKeng坐标时，你会看到此服务输出的一个渲染的版本，将显示最近的在openLooKeng上执行的查询。 GET /v1/query/{queryId} 可调用此服务收集详细的有关查询的统计数据。如果您加载openLooKeng协调节点的Web界面，您会看到一个关于当前查询的清单。单击查询将显示指向此服务的链接。 响应样例： { "queryId" : "20131229_211533_00017_dk5x2", "session" : { "user" : "tobrien", "source" : "openlk-cli", "catalog" : "jmx", "schema" : "jmx", "remoteUserAddress" : ""192.168.1.1"", "userAgent" : "StatementClient/0.55-SNAPSHOT", "startTime" : 1388351852026 }, "state" : "FINISHED", "self" : "http://127.0.0.1:8080/v1/query/20131229_211533_00017_dk5x2", "fieldNames" : [ "name" ], "query" : "select name from \"java.lang:type=runtime\"", "queryStats" : { "createTime" : "2013-12-29T16:17:32.027-05:00", "executionStartTime" : "2013-12-29T16:17:32.
阶段资源 GET /v1/stage 返回openLooKeng查询中有关阶段的详细信息。 DELETE /v1/stage/{stageId} 删除openLooKeng查询中的指定阶段。
语句资源 POST /v1/statement query query 需要执行的SQL查询 reqheader X-Presto-User 代表(optional)执行语句的用户 reqheader X-Presto-Source 查询的来源 reqheader X-Presto-Catalog 执行查询基于的目录 reqheader X-Presto-Schema 执行查询的模式 提交语句给openLooKeng执行。openLooKeng客户端代表用户根据指定的目录和架构进行查询。当使用openLooKeng命令行进行查询时，则调用openLooKeng协调节点的语句资源。 对语句资源的请求就是和标准X-Presto-Catalog、X-Presto-Source、X-Presto-Schema和X-Presto-User头域一起作为post执行的SQL查询。 语句资源的响应包含一个查询标识符，该标识符可用于收集有关查询的详细信息。初始响应还包括有关为执行此查询而在openLooKeng worker上创建的阶段的信息。每个查询都有一个根阶段，并且根阶段被赋予一个"0"的阶段标识符，如下面的响应示例所示。 这个根阶段聚合了在openLooKeng worker上运行的其他阶段的响应，并通过openLooKeng协调节点将它们传递给客户端。 当一个客户端收到这个POST的响应时，它将包含一个"nextUri"属性，这个属性指示客户端查询这个地址以获得查询的更多结果。 请求样例： POST /v1/statement HTTP/1.1 Host: localhost:8001 X-Presto-Catalog: jmx X-Presto-Source: presto-cli X-Presto-Schema: jmx User-Agent: StatementClient/0.55-SNAPSHOT X-Presto-User: tobrie1 Content-Length: 41 select name from "java.lang:type=runtime" 响应样例： HTTP/1.1 200 OK Content-Type: application/json X-Content-Type-Options: nosniff Transfer-Encoding: chunked { "id":"20140108_110629_00011_dk5x2", "infoUri":"<http://localhost:8001/v1/query/20140108_110629_00011_dk5x2>", "partialCancelUri":"<http://192.
任务资源 任务资源提供了一组REST端点，这些端点使openLooKeng服务器能够就任务和任务输出进行交流。这不是一个供最终用户使用的服务，但它支持在openLooKeng上执行查询任务。 GET /v1/task 返回openLooKeng服务器已知的所有任务的信息。 注意，对/v1/task的调用的输出可能相当大。如果你对忙碌的openLooKeng服务器执行这个命令，收到的响应将包括该服务器已知的每个任务的列表以及详细的操作符和驱动的统计信息。 为了便于本手册描述，下列的示例响应经过适当的删减。一个高负荷的openLooKeng服务器实际的响应输出可能有很多页。下面是一个状态为CANCELED的任务的taskId。 响应样例： [ { "taskId" : "20131222_183944_00011_dk5x2.1.0", "version" : 9223372036854775807, "state" : "CANCELED", "self" : "unknown", "lastHeartbeat" : "2013-12-22T13:54:46.566-05:00", "outputBuffers" : { "state" : "FINISHED", "masterSequenceId" : 0, "pagesAdded" : 0, "buffers" : [ ] }, "noMoreSplits" : [ ], "stats" : { "createTime" : "2013-12-22T13:54:46.566-05:00", "elapsedTime" : "0.00ns", "queuedTime" : "92.00us", "totalDrivers" : 0, "queuedDrivers" : 0, "runningDrivers" : 0, "completedDrivers" : 0, "memoryReservation" : "0B", "totalScheduledTime" : "0.
内置系统访问控制 系统访问控制插件在任何连接器级别授权之前，对全局级别强制授权。您可以选择使用openLooKeng的任一内置的插件，或者按照系统访问控制中的指导提供您自己的插件。openLooKeng提供了三个内置插件： 插件 说明 allow-all（缺省值） 允许所有操作。 read-only 允许读数据或读元数据的操作，但不允许写数据或写元数据的操作。有关详细信息，请参阅”只读系统访问控制”。 file 使用配置属性security.config-file指定的配置文件执行授权检查。有关详细信息，请参阅“基于文件的系统访问控制”。 允许所有系统访问控制 此插件允许所有操作。此插件默认开启。 只读系统访问控制 通过此插件，您可以执行任何读取数据或元数据的操作，例如SELECT或SHOW。还允许设置系统级或目录级会话属性。但是禁止任何写数据或元数据的操作，如CREATE、INSERT、DELETE等。 要使用此插件，请添加etc/access-control.properties文件，文件内容如下： access-control.name=read-only 基于文件的系统访问控制 此插件允许您在文件中设置访问控制规则。要使用该插件，需要添加一个etc/access-control.properties文件，其中必需包含两个属性：access-control.name属性，必须等于file；security.config-file属性，必须等于配置文件所在的位置。例如，配置文件rules.json位于etc目录，则添加etc/access-control.properties文件，内容如下： access-control.name=file security.config-file=etc/rules.json 配置文件必须是JSON格式，它包含： 定义哪个用户可以访问哪些目录的规则（见下面的目录规则）。 明确哪些主体可以标识为哪些用户的规则（见下文的主体规则）。 此插件目前仅支持目录访问控制规则和主体规则。如果您想以任何其他方式进行系统级访问限制，您必须实现一个自定义的SystemAccessControl插件（参见系统访问控制）。 刷新 默认情况下，修改security.config-file后，必须重新启动openLooKeng以加载所做的更改。有一个可选的属性可以不需要重启openLooKeng就能刷新属性。刷新周期在etc/access-control.properties中指定： security.refresh-period=1s 目录规则 目录规则控制特定用户可以访问的目录。根据从上到下读取匹配到的第一个规则，授予用户访问目录的权限。如果没有匹配到任何规则，则拒绝访问。每条规则由以下字段组成： user（可选）：用于匹配用户名的正则表达式。默认为.*。 catalog（可选）:用于匹配目录名的正则表达式。默认为.*。 allow（必选）: 字符串参数，表示用户是否有访问目录的权限。这个值可以是all、read-only或none，默认为none。将此值设置为read-only，其行为与只读的系统访问控制插件相同。 注意 默认情况下，所有用户都可以访问system目录。您可以通过添加规则来改变此行为。 例如，如果希望仅允许admin用户访问mysql和system目录，允许所有用户访问hive目录，允许alice用户只读地访问postgresql，拒绝其他用户访问，则可以定义以下规则： { "catalogs": [ { "user": "admin", "catalog": "(mysql|system)", "allow": all }, { "catalog": "hive", "allow": all }, { "user": "alice", "catalog": "postgresql", "allow": "read-only" }, { "catalog": "system", "allow": none } ] } 用户模拟规则 用户模拟规则用于控制一个用户模拟另一个用户的能力。在某些环境中，希望管理员（或管理系统）代表其他用户运行查询，这时管理员将使用其凭据进行身份认证，然后以其他用户提交查询。当用户上下文改变后，openLooKeng将验证管理员是否有权以目标用户身份运行查询。
CLI接口的Kerberos认证 openLooKeng命令行接口可以连接到启用了Kerberos认证的openLooKeng协调节点。 环境配置 Kerberos服务 客户端通过网络访问的节点上需要运行Kerberos KDC（密钥分发中心）。KDC负责对主体进行身份验证，并为启用Kerberos的服务发布会话密钥。KDC通常在端口88上运行，该端口是IANA为Kerberos分配的端口。 MIT Kerberos配置 需要在客户端进行Kerberos配置。至少需要在/etc/krb5.conf文件中的[realms]小节中有一个kdc条目。还需要增加一个admin_server条目，并确保客户端能够通过端口749访问Kerberos管理服务器。 [realms] OPENLOOKENG.EXAMPLE.COM = { kdc = kdc.example.com admin_server = kdc.example.com } [domain_realm] .openlookeng.example.com = OPENLOOKENG.EXAMPLE.COM openlookeng.example.com = OPENLOOKENG.EXAMPLE.COM krb5.conf的完整文档由麻省理工学院Kerberos项目托管。如果您使用Kerberos协议的不同实现方式，则需要根据您的环境修改配置。 Kerberos主体和Keytab文件 连接到openLooKeng协调节点的每个用户都需要一个Kerberos主体。您需要使用kadmin在Kerberos中创建这些用户。 另外，每个用户需要一个keytab文件。创建主体后，可使用 kadmin创建keytab文件。 kadmin > addprinc -randkey someuser@EXAMPLE.COM > ktadd -k /home/someuser/someuser.keytab someuser@EXAMPLE.COM 注意 运行ktadd命令将会使主体的密钥随机化。如果您刚刚创建了主体，这无关紧要。如果主体已经存在，并且现有的用户或服务依赖于使用密码或keytab进行验证，则在运行ktadd时需要增加-norandkey选项。 Java加密扩展策略文件 JRE自带策略文件以限制可使用的加密密钥的强度。但默认情况下，Kerberos使用的密钥比策略文件支持的密钥要大。有两种可能的解决方案： 更新JCE策略文件。 配置Kerberos，使用强度降低的密钥。 推荐采用更新JCE策略文件的方案。JCE策略文件可以从Oracle下载。请注意，JCE策略文件因Java主版本而异。例如，Java6的策略文件不能在Java 8中使用。 Java 8策略文件可以从这里获取。ZIP归档文件的README文件中有安装策略文件的说明。如果要在系统JRE中安装策略文件，则需要管理级别的访问权限。 TLS使用的Java 密钥库文件 使用Kerberos身份验证时，必须通过https访问openLooKeng协调节点。openLooKeng协调节点使用Java密钥库文件进行TLS配置。该文件可以复制到客户端，并用于其配置。 openLooKeng命令行执行 如果调用使能了Kerberos的CLI，除了连接到不需要Kerberos身份验证的openLooKeng协调节点时所需的选项之外，还需要一些额外的命令行选项。调用CLI的最简单方法是使用包装脚本。 #!/bin/bash ./openlk-cli \ --server https://openlookeng-coordinator.example.com:7778 \ --krb5-config-path /etc/krb5.conf \ --krb5-principal someuser@EXAMPLE.
Hazelcast安全 Hazelcast是内嵌在openLooKeng进程中，在openLooKeng中使用Hazelcast时，为了保障Hazelcast的客户端与服务端，以及各个服务端成员之间的通信安全， 建议开启Hazelcast的认证与SSL/TLS通道加密。 Hazelcast认证 Hazelcast当前只支持Kerberos认证。由于Hazelcast是由state-store模块调用，因此开启Hazelcast认证，需先启用state-store。 state-store启用后，在state-store的配置文件state-store.properties中增加如下配置： hazelcast.kerberos.enable=true hazelcast.kerberos.login.context.name=Hazelcast hazelcast.kerberos.service.principal=openlookeng hazelcast.kerberos.krb5.conf=/etc/krb5.conf hazelcast.kerberos.auth.login.config=/etc/jaas.conf 属性 描述 hazelcast.kerberos.enable 为Hazelcast开启Kerberos认证功能。默认设置为false。 hazelcast.kerberos.login.context.name 登陆Kerberos的context名。 hazelcast.kerberos.service.principal Hazelcast的Kerberos服务主体名。 hazelcast.kerberos.krb5.conf kerberos配置文件所在的位置。 hazelcast.kerberos.auth.login.config 登陆Kerberos配置文件所在的位置。 登陆Kerberos配置文件jaas.conf格式如下，配置时需先在Kerberos创建机机用户，并将创建的用户的principal，keytab按照如下格式配置 Hazelcast { com.sun.security.auth.module.Krb5LoginModule required useKeyTab=true principal="openlookeng" keyTab="/etc/openlookeng.keytab" useTicketCache=false storeKey=true; }; 属性 描述 principal 登陆Kerberos的主体名。 keyTab 登陆Kerberos主体进行身份验证的keytab文件的位置。 注意： 所有节点的配置文件相同，包括机机用户的principal，keyTab。
内部通信安全 openLooKeng集群可以通过配置使用安全通信。 可使用SSL/TLS确保openLooKeng节点间的通信安全。 内部SSL/TLS配置 在config.properties文件中进行SSL/TLS配置。使用相同的属性对工作（worker)节点和协调(coordinator)节点上的SSL/TLS进行配置。集群中每个节点都需要进行配置。未配置SSL/TLS或配置错误的节点将无法与集群中的其他节点进行通信。 为openLooKeng内部通信启用SSL/TLS功能，执行以下步骤： 禁用HTTP端点。 http-server.http.enabled=false 警告 可以在不禁用HTTP的情况下，开启HTTPS。但在大多数情况下，这会有安全风险。 如果您确定要使用此配置，则应考虑使用防火墙来确保HTTP端点不被非法的主机访问。 配置集群使用集群节点的FQDN（全量域名）进行通信。可通过以下两种方式实现： 如果DNS服务配置正常，可以让节点使用从系统配置获得的主机名（hostname --fqdn）向协调节点介绍自己。 node.internal-address-source=FQDN 手动指定每个节点的完全限定主机名。每台主机的主机名应该不同。主机应该在同一个域中，以便创建正确的SSL/TLS证书。如：coordinator.example.com, worker1.example.com, worker2.example.com. node.internal-address=<node fqdn> 生成Java 密钥库文件。每个openLooKeng节点必须能够连接到同一集群中的任何其他节点。可以使用每台主机的完全限定主机名为每个节点创建唯一的证书，创建包含所有主机的所有公钥的密钥库，并为客户端指定密钥库（见下面的步骤8）。在大多数情况下，在证书中使用通配符会更简单，如下所示。 keytool -genkeypair -alias openLooKeng -keyalg RSA -keystore keystore.jks -keysize 2048 Enter keystore password: Re-enter new password: What is your first and last name? [Unknown]: *.example.com What is the name of your organizational unit? [Unknown]: What is the name of your organization?
LDAP认证 通过配置openLooKeng，可以为客户端（如cli_ldap）或JDBC、ODBC驱动启用HTTPS访问的前端LDAP认证。目前只支持涉及用户名和密码的简单的LDAP认证机制。openLooKeng客户端将用户名和密码发送给协调节点，协调节点使用外部LDAP服务验证这些凭据。 为了给openLooKeng启用LDAP身份验证，需要修改openLooKeng协调节点上的配置。Worker节点上的配置不需要更改，只为仅验证从客户端到协调节点的通信。但是，如果您希望使用SSL/TLS来确保openLooKeng节点之间的通信安全，需要配置/security/internal- communication。 openLooKeng服务器配置 环境配置 安全LDAP协议 openLooKeng需要安全的LDAP (LDAPS)协议，所以请确保在LDAP服务器上启用了TLS。 openLooKeng协调节点的TLS配置 您需要将LDAP服务器的TLS证书导入到openLooKeng协调节点默认的Java信任库中，以保证TLS连接的安全。可以使用下面的示例中的keytool命令将证书ldap_server.crt导入到协调节点上的信任库中。 $ keytool -import -keystore <JAVA_HOME>/jre/lib/security/cacerts -trustcacerts -alias ldap_server -file ldap_server.crt 除此之外，使用HTTPS访问openLooKeng协调节点。您可以通过在协调节点上创建server_java_keystore来实现。 openLooKeng协调节点配置 在配置openLooKeng协调节点使用LDAP身份验证和HTTPS之前，必须对环境进行下列更改: ldap_server server_java_keystore 您还需要对openLooKeng配置文件进行修改。LDAP认证在协调节点上分为两部分进行配置。第一部分是在协调节点的config.properties文件中启用HTTPS和密码认证。 第二部分是将LDAP配置为密码验证器插件。 服务器配置属性 以下示例列出了需要在协调节点的config.properties文件中添加的属性： http-server.authentication.type=PASSWORD http-server.https.enabled=true http-server.https.port=8443 http-server.https.keystore.path=/etc/openLooKeng.jks http-server.https.keystore.key=keystore_password 属性 描述 http-server.authentication.type 对openLooKeng协调节点开启密码认证功能。必须设置为PASSWORD。 http-server.https.enabled 对openLooKeng协调节点开启HTTPS访问功能。取值设置为true。默认值为false。 http-server.https.port HTTPS服务器的端口号。 http-server.https.keystore.path 用于保证TLS安全连接的Java密钥库文件的位置。 http-server.https.keystore.key 密钥库的密码。必须与创建密钥库时设置的密码一致。 http-server.authentication.password.user-mapping.pattern 用于认证用户匹配的正则表达式。如果匹配，认证用户映射到正则表达式中的第一个匹配组；如果不匹配，则拒绝认证。默认值是(.*)。 http-server.
密码加密 概要 openLooKeng 管理一些catalog相关的配置文件，这些配置文件可能包含一些用户名、密码等信息，其中，密码信息一般情况下要求保密，不能以明文的方式存储。 这是一个典型的MySQL connector的配置文件： connector.name=mysql connection-url=jdbc:mysql://localhost:3306 connection-user=root connection-password=123456 openLooKeng 可以开启密码加密功能，这些密码就可以被加密存储。 建议RSA Key的长度为3072 bit，最低2048 bit。 原理 我们采用非对称加密算法 (RSA)，原理如下： 公钥： 用于加密，客户端使用公钥对明文进行加密。 私钥： 用户解密，服务端将私钥存储在文件系统的keystore中，并使用私钥对密文进行解密。 用户自己保存公钥，将私钥给openLooKeng用于加密后的密文解密。 配置 为了开启密码加密特性，你需要在 etc/config.properties增加以下属性： security.password.decryption-type=RSA security.key.manager-type=keystore security.key.keystore-password=my-keystore-pwd security.key.store-file-path=/openlookeng/keystore/keystore.jks 属性 描述 security.password.decryption-type 密码加解密使用的加密算法. 必须是 NONE 或 RSA. security.key.manager-type=keystore 加密秘钥的存储方式. 必须是 keystore. security.key.keystore-password keystore的密码. security.key.cipher-transformations Cipher.getInstance(transformations), the default value is ‘RSA/ECB/OAEPWITHSHA256AndMGF1Padding’ security.key.store-file-path 文件系统 中keystore文件的路径.
Ranger 访问控制 概要 Apache Ranger 为 Hadoop 集群提供了一种全面的安全框架，以跨组件的、一致性的方式进行定义、授权、管理安全策略。Ranger 详细介绍和用户指导可以参考Apache Ranger Wiki。 openlookeng-ranger-plugin 基于Ranger 2.1.0版本进行开发，是为 openLooKeng 开发的 Ranger 插件，用于全面的数据安全监控和权限管理。 编译过程 从 Git 仓库检出 openlookeng-ranger-plugin 代码 进入代码根目录，执行 Maven 命令： mvn clean package 在上述 Maven 命令执行完成后，可以在 target 目录发现以下 TAR 文件： ranger-<ranger.version>-admin-openlookeng-<openlookeng.version>-plugin.tar.gz ranger-<ranger.version>-openlookeng-<openlookeng.version>-plugin.tar.gz 部署过程 安装 Ranger Admin 插件 1). 解压 ranger-<ranger.version>-admin-openlookeng-<openlookeng.version>-plugin.tar.gz，可以发现以下目录： openlookeng service-defs 2). Ranger 服务类型定义的注册 使用 Ranger Admin 提供的 REST API 向 Ranger 注册服务类型定义。注册后，Ranger Admin 将提供 UI 以创建服务实例（在以前的版本中称为存储库）和服务类型策略。Ranger 插件使用服务类型定义和策略来确定请求是否有访问权限以进行授权。如下示例所示，可以使用 curl 命令调用 REST API 接口注册服务：
协调节点Kerberos认证 可以配置openLooKeng协调节点，为客户端（例如openLooKeng命令行或JDBC和ODBC驱动程序）启用基于HTTPS的Kerberos身份验证。 为了启用Kerberos身份验证，需要修改在openLooKeng协调节点上的配置。不需要修改在工作节点上的配置。工作节点将继续通过未经身份验证的HTTP连接到协调节点。但是，如果需要确保openLooKeng节点之间使用SSL/TLS通信，则需要配置“内部通信安全”。 环境配置 Kerberos服务 openLooKeng协调节点通过网络访问的节点上需要运行Kerberos KDC（密钥分发中心）。KDC负责对主体进行身份验证，并为启用Kerberos的服务发布会话密钥。KDC通常在端口88上运行，该端口是IANA为Kerberos分配的端口。 MIT Kerberos配置介绍 Kerberos需要在openLooKeng协调节点上配置。至少需要在/etc/krb5.conf文件中的[realms]小节中有一个kdc条目。还可以增加一个admin_server条目，确保openLooKeng协调节点能够访问端口749上的Kerberos管理服务器。 [realms] OPENLOOKENG.EXAMPLE.COM = { kdc = kdc.example.com admin_server = kdc.example.com } [domain_realm] .openlookeng.example.com = OPENLOOKENG.EXAMPLE.COM openlookeng.example.com = OPENLOOKENG.EXAMPLE.COM Krb5.conf的完整文档由麻省理工学院Kerberos项目托管。如果您使用Kerberos协议的不同实现方式，则需要根据您的环境修改配置。 Kerberos主体和Keytab文件 openLooKeng协调节点需要一个Kerberos主体，需要连接到openLooKeng协调节点的用户也需要一个Kerberos主体。可以使用kadmin在Kerberos中创建这些用户。 另外，openLooKeng协调节点需要一个 keytab文件。创建主体后，可以使用kadmin创建keytab文件。 kadmin > addprinc -randkey openlookeng@EXAMPLE.COM > addprinc -randkey openlookeng/openlookeng-coordinator.example.com@EXAMPLE.COM > ktadd -k /etc/openlookeng/openlookeng.keytab openlookeng@EXAMPLE.COM > ktadd -k /etc/openlookeng/openlookeng.keytab openlookeng/openlookeng-coordinator.example.com@EXAMPLE.COM 注意 运行ktadd会使主体的密钥随机化。如果您刚刚创建了主体，这无关紧要。如果主体已经存在，并且现有用户或服务依赖于能够使用密码或keytab进行验证，则运行ktadd时增加-norandkey选项。 Java加密扩展策略文件 JRE自带策略文件以限制可使用的加密密钥的强度。但默认情况下，Kerberos使用的密钥比策略文件支持的密钥要大。有两种可能的解决方案： 更新JCE策略文件。 配置Kerberos，使用强度降低的密钥。 推荐采用更新JCE策略文件的方案。JCE策略文件可以从Oracle下载。请注意，JCE策略文件因Java主版本而异。例如，Java6的策略文件不能在Java 8中使用。 Java 8策略文件可以从这里获取。ZIP归档文件的README文件中有安装策略文件的说明。如果要在系统JRE中安装策略文件，则需要管理级别的访问权限。 TLS使用的Java 密钥库文件 使用Kerberos身份验证时，应该通过HTTPS访问openLooKeng协调节点。您可以通过在协调节点上创建用于TLS连接的Java密钥库文件来实现。 系统访问控制插件 启用Kerberos的openLooKeng协调节点可能需要一个系统访问控制插件来达到所需的安全级别。
Java密钥库和信任库 TLS的Java密钥库文件 使用Kerberos和LDAP身份验证时，必须通过HTTPS访问openLooKeng协调节点。openLooKeng协调节点使用JavaKeystore<server_java_keystore>文件进行TLS配置。这些密钥使用keytool生成，并存储在Java 密钥库文件中，供openLooKeng协调节点使用。 keytool命令行中的别名应与openLooKeng协调节点将要使用的主体匹配。系统将提示您输入姓名。使用将要在证书中使用的Common Name。在这种情况下，它应该是openLooKeng协调节点的非限定主机名。在下面的例子中，在确认信息正确的提示中可以看到这一点： keytool -genkeypair -alias openlookeng -keyalg RSA -keystore keystore.jks Enter keystore password: Re-enter new password: What is your first and last name? [Unknown]: openlookeng-coordinator.example.com What is the name of your organizational unit? [Unknown]: What is the name of your organization? [Unknown]: What is the name of your City or Locality? [Unknown]: What is the name of your State or Province? [Unknown]: What is the two-letter country code for this unit?
认证用户映射 认证用户映射定义了从认证系统中的用户到openLooKeng用户的映射规则。认证用户映射对于具有例如alice@example或CN=Alice Smith, OU=Finance, O=Acme, C=US等复杂用户名的Kerberos或LDAP认证特别重要。 可以使用简单的正则表达式模式匹配配置用户映射，也可以在单独的配置文件中配置更复杂的映射规则。 模式映射规则 模式映射规则将认证用户映射到正则表达式中的第一个匹配组。如果正则表达式与认证用户不匹配，则拒绝认证。 每个身份认证系统都具有单独的用户映射模式的属性，以在启用多个身份认证系统时允许不同的映射： 认证方式 属性 Username and Password (LDAP) http-server.authentication.password.user-mapping.pattern Kerberos http-server.authentication.krb5.user-mapping.pattern Certificate http-server.authentication.certificate.user-mapping.pattern Json Web Token http-server.authentication.jwt.user-mapping.pattern 文件映射规则 文件映射规则允许认证用户配置更复杂的映射。这些映射规则是从配置属性中定义的JSON文件加载的，基于从上到下第一个匹配的规则进行映射，如果没有规则匹配，则认证被拒绝。每个规则由以下字段组成： 字段名称 默认值 是否必填 描述 pattern (none) 是 用于认证用户匹配的正则表达式 user $1 否 替换模式匹配的字符串 allow true 否 布尔值，指示是否允许认证 如以下示例所示，除了test用户拒绝认证外，会将alice@example.
ALTER SCHEMA 摘要 ALTER {SCHEMA|DATABASE} name RENAME TO new_name 说明 更改现有模式的定义。 示例 将模式 web 重命名为 traffic： ALTER SCHEMA web RENAME TO traffic ALTER DATABASE web RENAME TO traffic 限制 某些连接器（如 Hive 连接器）不支持重命名模式。有关更多详细信息，请参见连接器文档。 另请参见 CREATE SCHEMA
ALTER TABLE 摘要 ALTER TABLE name RENAME TO new_name ALTER TABLE name ADD COLUMN column_name data_type [ COMMENT comment ] [ WITH ( property_name = expression [, ...] ) ] ALTER TABLE name DROP COLUMN column_name ALTER TABLE name RENAME COLUMN column_name TO new_column_name 说明 更改现有表的定义。 示例 将表 users 重命名为 people： ALTER TABLE users RENAME TO people; 在 users 表中添加 zip 列： ALTER TABLE users ADD COLUMN zip varchar; 从 users 表中删除 zip 列：
ANALYZE 摘要 ANALYZE table_name [ WITH ( property_name = expression [, ...] ) ] 说明 收集给定表的表和列统计信息。 可选的 WITH 子句可用于提供特定于连接器的属性。要列出所有可用的属性，请运行以下查询： SELECT * FROM system.metadata.analyze_properties 目前仅 Hive连接器支持该语句。 示例 分析表 web 以收集表和列统计信息： ANALYZE web; 分析目录 hive 和模式 default 中的表 stores： ANALYZE hive.default.stores; 分析 Hive 分区表 sales 中的分区 '1992-01-01', '1992-01-02'： ANALYZE hive.default.sales WITH (partitions = ARRAY[ARRAY['1992-01-01'], ARRAY['1992-01-02']]); 分析 Hive 分区表 customers 中具有复杂分区键（state 和 city 列）的分区。 ANALYZE hive.default.customers WITH (partitions = ARRAY[ARRAY['CA', 'San Francisco'], ARRAY['NY', 'NY']]);
CACHE TABLE 摘要 CACHE TABLE table_name WHERE condition; 说明 CACHE TABLE 使用连接器应缓存的表名和分区更新协调器元数据。 目前必须提供“ condition”，并且仅在分区列上定义。 示例 缓存“ CA”中商店的所有销售数据: CACHE TABLE store_sales WHERE location = 'CA'; 缓存2020年2月20日之后出售的商店中的所有销售数据。 CACHE TABLE store_sales WHERE ss_sold_date_sk > 20200220; 缓存拥有复杂 condition 的数据 CACHE TABLE store_sales WHERE location = 'CA' AND ss_sold_date_sk > 20200220; 限制 目前只有Hive连接器(ORC格式)支持此功能。 有关更多详细信息，请参见连接器文档。 目前 WHERE 中不支持 LIKE 字段。 目前不支持 WHERE 中的 OR 运算符。 另请参见 SHOW CACHE、DROP CACHE
CALL 摘要 CALL procedure_name ( [ name => ] expression [, ...] ) 说明 调用过程。 过程可以由连接器提供，以执行数据操作或管理任务。例如，/connector/system定义了用于终止正在运行的查询的过程。 某些连接器（如 PostgreSQL连接器）用于具有其自己的存储过程的系统。这些存储过程与此处讨论的连接器定义过程相分离，因此无法通过 CALL 直接调用。 有关可用过程的详细信息，请参见连接器文档。 示例 使用位置参数调用过程： CALL test(123, 'apple'); 使用命名参数调用过程： CALL test(name => 'apple', id => 123); 使用完全限定名称调用过程： CALL catalog.schema.test();
COMMENT 摘要 COMMENT ON TABLE name IS 'comments' 说明 设置表的注释。可以通过将注释设置为 NULL 来删除注释。 示例 将 users 表的注释更改为 master table： COMMENT ON TABLE users IS 'master table';
COMMIT 摘要 COMMIT [ WORK ] 说明 提交当前事务。 示例 COMMIT; COMMIT WORK; 另请参见 ROLLBACK、START TRANSACTION
CREATE ROLE 摘要 CREATE ROLE role_name [ WITH ADMIN ( user | USER user | ROLE role | CURRENT_USER | CURRENT_ROLE ) ] 说明 CREATE ROLE 在当前目录中创建指定的角色。 如果使用可选的 WITH ADMIN 子句，则在创建角色时使指定的用户成为角色管理员。角色管理员具有删除或授予角色的权限。如果未指定可选的 WITH ADMIN 子句，在创建角色时使当前用户成为角色管理员。 示例 创建角色 admin： CREATE ROLE admin; 创建角色 moderator 并使 bob 成为角色管理员： CREATE ROLE moderator WITH ADMIN USER bob; 限制 某些连接器不支持角色管理。有关更多详细信息，请参见连接器文档。 另请参见 DROP ROLE、SET ROLE、GRANT ROLES、REVOKE ROLES
CREATE SCHEMA 摘要 CREATE {SCHEMA|DATABASE} [ IF NOT EXISTS ] schema_name [ WITH ( property_name = expression [, ...] ) ] 说明 创建一个空模式。模式是保存表、视图和其他数据库对象的容器。 如果使用可选的 IF NOT EXISTS 子句，则在模式已存在时禁止显示错误。 可以使用可选的 WITH 子句来设置创建的模式的属性。要列出所有可用的模式属性，请运行以下查询： SELECT * FROM system.metadata.schema_properties 示例 在当前目录中创建模式 web： CREATE SCHEMA web CREATE DATABASE web 在 hive 目录中创建模式 sales： CREATE SCHEMA hive.sales 如果模式 traffic 尚不存在，则创建该模式： CREATE SCHEMA IF NOT EXISTS traffic 另请参见 ALTER SCHEMA、DROP SCHEMA
CREATE TABLE AS 摘要 CREATE TABLE [ IF NOT EXISTS ] table_name [ ( column_alias, ... ) ] [ COMMENT table_comment ] [ WITH ( property_name = expression [, ...] ) ] AS query [ WITH [ NO ] DATA ] 说明 创建一个包含 SELECT 查询结果的表。使用 CREATE TABLE 可以创建空表。 如果使用可选的 IF NOT EXISTS 子句，则在表已存在时禁止显示错误。 可以使用可选的 WITH 子句来设置创建的表的属性。要列出所有可用的表属性，请运行以下查询： SELECT * FROM system.metadata.table_properties 示例 使用查询结果和给定的列名创建表 orders_column_aliased： CREATE TABLE orders_column_aliased (order_date, total_price) AS SELECT orderdate, totalprice FROM orders 创建对 orders 进行汇总的表 orders_by_date：
CREATE TABLE 摘要 CREATE TABLE [ IF NOT EXISTS ] table_name ( { column_name data_type [ COMMENT comment ] [ WITH ( property_name = expression [, ...] ) ] | LIKE existing_table_name [ { INCLUDING | EXCLUDING } PROPERTIES ] } [, ...] ) [ COMMENT table_comment ] [ WITH ( property_name = expression [, ...] ) ] 说明 创建一个具有指定列的空表。使用 create-table-as 可以创建含数据的表。 如果使用可选的 IF NOT EXISTS 子句，则在表已存在时禁止显示错误。 可以使用可选的 WITH 子句来设置创建的表或单个列的属性。要列出所有可用的表属性，请运行以下查询：
CREATE VIEW 摘要 CREATE [ OR REPLACE ] VIEW view_name [ SECURITY { DEFINER | INVOKER } ] AS query 说明 创建 SELECT 查询的视图。视图是一个可以由将来的查询引用的逻辑表。视图不包含任何数据。相反，视图存储的查询在每次被其他查询引用时执行。 如果使用可选的 OR REPLACE 子句，则在视图已存在时替换该视图，而不是产生错误。 安全 在默认的 DEFINER 安全模式下，使用视图拥有者（视图的创建者或定义者）的权限来访问视图中引用的表，而不是使用执行查询的用户的权限。这样，对于用户可能无法直接访问的基础表，可以提供对这些表的受限访问。 在 INVOKER 安全模式下，使用执行查询的用户（视图的调用者）的权限来访问在视图中引用的表。以该模式创建的视图只是一个存储查询。 无论安全模式如何，current_user 函数都始终返回执行查询的用户，因此可以在视图中使用该函数来滤除行或限制访问。 示例 在表 orders 上创建简单视图 test： CREATE VIEW test AS SELECT orderkey, orderstatus, totalprice / 2 AS half FROM orders 创建对 orders 进行汇总的视图 orders_by_date： CREATE VIEW orders_by_date AS SELECT orderdate, sum(totalprice) AS price FROM orders GROUP BY orderdate 创建一个替换现有视图的视图：
DEALLOCATE PREPARE 摘要 DEALLOCATE PREPARE statement_name 说明 从会话中的预编译语句列表中删除名称为 statement_name 的语句。 示例 取消分配名称为 my_query 的语句： DEALLOCATE PREPARE my_query; 另请参见 PREPARE
DELETE 摘要 DELETE FROM table_name [ WHERE condition ] 说明 删除表中的行。如果指定了 WHERE 子句，则仅删除匹配的行。否则，将删除表中的所有行。 示例 删除所有空运行项目： DELETE FROM lineitem WHERE shipmode = 'AIR'; 删除低优先级订单的所有行项目： DELETE FROM lineitem WHERE orderkey IN (SELECT orderkey FROM orders WHERE priority = 'LOW'); 删除所有订单： DELETE FROM orders; 限制 某些连接器对 DELETE 的支持有限或不支持该语句。 例如，对于 Hive 连接器，事务表和非事务表的行为是不同的。 对于事务表，可以通过 WHERE 条件来删除任何行。不过，对于非事务表，仅当 WHERE 子句匹配整个分区时才支持 DELETE。 有关更多详细信息，请参见连接器文档。
DESCRIBE INPUT 摘要 DESCRIBE INPUT statement_name 说明 列出预编译语句的输入参数以及每个参数的位置和类型。无法确定的参数类型将显示为 unknown。 示例 预编译并描述一个具有三个参数的查询： PREPARE my_select1 FROM SELECT ? FROM nation WHERE regionkey = ? AND name < ?; DESCRIBE INPUT my_select1; Position | Type -------------------- 0 | unknown 1 | bigint 2 | varchar (3 rows) 预编译并描述一个不具有参数的查询： PREPARE my_select2 FROM SELECT * FROM nation; DESCRIBE INPUT my_select2; Position | Type ----------------- (0 rows) 另请参见 PREPARE
DESCRIBE OUTPUT 摘要 DESCRIBE OUTPUT statement_name 说明 列出预编译语句的输出列，包括列名（或别名）、目录、模式、表、类型、类型大小（以字节为单位）以及表明列是否为别名的布尔值。 示例 预编译并描述一个具有四个输出列的查询： PREPARE my_select1 FROM SELECT * FROM nation DESCRIBE OUTPUT my_select1; Column Name | Catalog | Schema | Table | Type | Type Size | Aliased -------------+---------+--------+--------+---------+-----------+--------- nationkey | tpch | sf1 | nation | bigint | 8 | false name | tpch | sf1 | nation | varchar | 0 | false regionkey | tpch | sf1 | nation | bigint | 8 | false comment | tpch | sf1 | nation | varchar | 0 | false (4 rows) 预编译并描述一个输出列是表达式的查询：
DESCRIBE 摘要 DESCRIBE table_name 说明 DESCRIBE 是 SHOW COLUMNS 的别名。
DROP CACHE 摘要 DROP CACHE table WHERE condition; 说明 DROP CACHE仅从协调节点中删除table的缓存元数据。工作节点的缓存数据会根据过期时间或者缓存大小而被自动清理。但当再次遇到重复的分片时，协调节点将不会把它分配到带缓存的工作节点。 示例 DROP CACHE 命令支持通过匹配条件字符串删除特定的缓存记录。例如，如果 SHOW CACHE 命令显示有一条名为 sale_id = 24 的缓存记录存储于 sales 表格下，那么运行下面的命令会将其删除且不影响其他的缓存记录。 DROP CACHE sales WHERE sale_id = 24; 或者删除 sales 表格下存储的所有缓存记录。 DROP CACHE sales; 限制 目前只有Hive连接器支持此功能。 有关更多详细信息，请参见连接器文档。 另请参见 CACHE TABLE、SHOW CACHE
DROP ROLE 摘要 DROP ROLE role_name 说明 DROP ROLE 删除当前目录中的指定角色。 为了使 DROP ROLE 语句成功执行，执行该语句的用户应拥有给定角色的管理员权限。 示例 删除角色 admin： DROP ROLE admin; 限制 某些连接器不支持角色管理。有关更多详细信息，请参见连接器文档。 另请参见 CREATE ROLE、SET ROLE、GRANT ROLES、REVOKE ROLES
DROP SCHEMA 摘要 DROP {SCHEMA|DATABASE} [ IF EXISTS ] schema_name [{CASCADE | RESTRICT}] 说明 删除一个现有的模式。该模式必须为空。 如果使用可选的 IF EXISTS 子句，则在该模式不存在时禁止显示错误。 示例 删除模式 web： DROP SCHEMA web DROP DATABASE web 如果模式 sales 存在，则删除该模式： DROP TABLE IF EXISTS sales 限制 从功能上而言，尚不支持 CASCADE 和 RESTRICT。 另请参见 ALTER SCHEMA、CREATE SCHEMA
DROP TABLE 摘要 DROP TABLE [ IF EXISTS ] table_name 说明 删除一个现有的表。 如果使用可选的 IF EXISTS 子句，则在该表不存在时禁止显示错误。 示例 删除表 orders_by_date： DROP TABLE orders_by_date 如果表 orders_by_date 存在，则删除该表： DROP TABLE IF EXISTS orders_by_date 另请参见 ALTER TABLE、CREATE TABLE
DROP VIEW 摘要 DROP VIEW [ IF EXISTS ] view_name 说明 删除一个现有的视图。 如果使用可选的 IF EXISTS 子句，则在该视图不存在时禁止显示错误。 示例 删除视图 orders_by_date： DROP VIEW orders_by_date 如果视图 orders_by_date 存在，则删除该视图： DROP VIEW IF EXISTS orders_by_date 另请参见 CREATE VIEW
EXECUTE 摘要 EXECUTE statement_name [ USING parameter1 [ , parameter2, ... ] ] 说明 执行名称为 statement_name 的预编译语句。在 USING 子句中定义参数值。 示例 预编译并执行一个不具有参数的查询： PREPARE my_select1 FROM SELECT name FROM nation; EXECUTE my_select1; 预编译并执行一个具有两个参数的查询： PREPARE my_select2 FROM SELECT name FROM nation WHERE regionkey = ? and nationkey < ?; EXECUTE my_select2 USING 1, 3; 这等效于： SELECT name FROM nation WHERE regionkey = 1 AND nationkey < 3; 另请参见 PREPARE
EXPLAIN ANALYZE 摘要 EXPLAIN ANALYZE [VERBOSE] statement 说明 执行语句并显示语句的分布式执行计划以及每个操作的开销。 VERBOSE 选项可提供更详细的信息和具体的统计数据；了解这些信息可能需要了解 openLooKeng 内部细节和实现细节。 注意 统计数据可能不完全准确，尤其是对于快速完成的查询。 示例 在下面的示例中，您可以看到每个阶段消耗的 CPU 时间，以及该阶段中每个计划节点的相对开销。请注意，计划节点的相对开销基于挂钟时间，挂钟时间可能与 CPU 时间相关，也可能与之不相关。对于每个计划节点，您都可以看到一些额外的统计数据（例如每个节点实例的平均输入以及相关计划节点的平均哈希冲突数）。当您希望检测查询的数据异常（偏斜、异常哈希冲突）时，这些统计数据很有用。 lk:sf1> EXPLAIN ANALYZE SELECT count(*), clerk FROM orders WHERE orderdate > date '1995-01-01' GROUP BY clerk; Query Plan ----------------------------------------------------------------------------------------------- Fragment 1 [HASH] Cost: CPU 88.57ms, Input: 4000 rows (148.44kB), Output: 1000 rows (28.32kB) Output layout: [count, clerk] Output partitioning: SINGLE [] - Project[] => [count:bigint, clerk:varchar(15)] Cost: 26.24%, Input: 1000 rows (37.
EXPLAIN 摘要 EXPLAIN [ ( option [, ...] ) ] statement where option can be one of: FORMAT { TEXT | GRAPHVIZ | JSON } TYPE { LOGICAL | DISTRIBUTED | VALIDATE | IO } 说明 显示语句的逻辑或分布式执行计划，或者对语句进行验证。使用 TYPE DISTRIBUTED 选项可以显示分片计划。每个计划片段由单个或多个 openLooKeng 节点执行。片段之间的间隔表示 openLooKeng 节点之间的数据交换。片段类型指定 openLooKeng 节点如何执行片段以及数据如何在片段之间分布： SINGLE 片段在单个节点上执行。 HASH 片段在固定数量的节点上执行，输入数据通过哈希函数进行分布。 ROUND_ROBIN 片段在固定数量的节点上执行，输入数据以轮循方式进行分布。 BROADCAST 片段在固定数量的节点上执行，输入数据广播到所有节点。 SOURCE 片段在访问输入分段的节点上执行。 示例 逻辑计划： lk:tiny> EXPLAIN SELECT regionkey, count(*) FROM nation GROUP BY 1; Query Plan ---------------------------------------------------------------------------------------------------------- - Output[regionkey, _col1] => [regionkey:bigint, count:bigint] _col1 := count - RemoteExchange[GATHER] => regionkey:bigint, count:bigint - Aggregate(FINAL)[regionkey] => [regionkey:bigint, count:bigint] count := "count"("count_8") - LocalExchange[HASH][$hashvalue] ("regionkey") => regionkey:bigint, count_8:bigint, $hashvalue:bigint - RemoteExchange[REPARTITION][$hashvalue_9] => regionkey:bigint, count_8:bigint, $hashvalue_9:bigint - Project[] => [regionkey:bigint, count_8:bigint, $hashvalue_10:bigint] $hashvalue_10 := "combine_hash"(BIGINT '0', COALESCE("$operator$hash_code"("regionkey"), 0)) - Aggregate(PARTIAL)[regionkey] => [regionkey:bigint, count_8:bigint] count_8 := "count"(*) - TableScan[tpch:tpch:nation:sf0.
GRANT ROLES 摘要 GRANT role [, ...] TO ( user | USER user | ROLE role) [, ...] [ GRANTED BY ( user | USER user | ROLE role | CURRENT_USER | CURRENT_ROLE ) ] [ WITH ADMIN OPTION ] 说明 将指定的角色授给当前目录中的指定主体。 如果指定了 WITH ADMIN OPTION 子句，则可以使用 GRANT 选项将角色授给用户。 为了使针对角色的 GRANT 语句成功执行，执行该语句的用户应具有管理员角色或者应对于给定的角色拥有 GRANT 选项。 可选的 GRANTED BY 子句可使指定的主体作为授予方来授给角色。如果未指定 GRANTED BY 子句，则当前用户作为授予方来授给角色。 示例 将角色 bar 授给用户 foo： GRANT bar TO USER foo; 将角色 bar 和 foo 授给用户 baz 和角色 qux 并使其具有管理员选项：
GRANT 摘要 GRANT ( privilege [, ...] | ( ALL PRIVILEGES ) ) ON [ TABLE ] table_name TO ( user | USER user | ROLE role ) [ WITH GRANT OPTION ] 说明 将指定的权限授给指定的被授权者。 指定 ALL PRIVILEGES 可以授予 DELETE、INSERT 和 SELECT 权限。 指定 ROLE PUBLIC 可以将权限授给 PUBLIC 角色，从而将权限授给所有用户。 通过使用可选的 WITH GRANT OPTION 子句，可以允许被授权者将同样的权限授给其他用户。 为了使 GRANT 语句成功执行，执行该语句的用户应拥有指定的权限并且对于这些权限拥有 GRANT OPTION。 示例 将对表 orders 的 INSERT 和 SELECT 权限授给用户 alice： GRANT INSERT, SELECT ON orders TO alice; 将对表 nation 的 SELECT 权限授给用户 alice，此外允许 alice 将 SELECT 权限授给其他用户：
INSERT OVERWRITE 摘要 INSERT OVERWRITE [TABLE] table_name [ ( column [, ... ] ) ] query 说明 insert overwrite 主要有两项功能：1) 根据查询创建的数据集删除数据行；2) 插入查询创建的新数据。 insert overwrite 可以对分区表和非分区表进行操作，但是行为不同： 对于非分区表，会直接删除所有的现有数据，然后插入新数据。 对于分区表，仅删除查询生成的数据集中存在的匹配分区数据，然后替换为新数据。 如果指定了列名列表，则该列表必须与查询生成的列列表完全匹配。会使用一个 null 值填充表中未在列列表中显示的列。如果未指定列列表，则查询生成的列必须与要插入的表中的列完全匹配。 示例 假设 orders 不是分区表，并且有 100 行，此时执行以下 insert overwrite 语句： INSERT OVERWRITE orders VALUES (1, 'SUCCESS', '10.25', DATA '2020-01-01'); 则 orders 表将仅有 1 行，即 VALUE 子句中指定的数据。 假设 users 有 3 列（id、name 和 state）并按照 state 进行分区，并且现有数据有以下行： id name state 1 John CD 2 Sam CD 3 Lucy SZ
INSERT 摘要 INSERT INTO table_name [ ( column [, ... ] ) ] query 说明 在表中插入新行。 如果指定了列名列表，则该列表必须与查询生成的列列表完全匹配。会使用一个 null 值填充表中未在列列表中显示的列。如果未指定列列表，则查询生成的列必须与要插入的表中的列完全匹配。 示例 将 new_orders 表中的其他行加载到 orders 表中： INSERT INTO orders SELECT * FROM new_orders; 在 cities 表中插入单行： INSERT INTO cities VALUES (1, 'San Francisco'); 在 cities 表中插入多行： INSERT INTO cities VALUES (2, 'San Jose'), (3, 'Oakland'); 使用指定的列列表在 nation 表中插入单行： INSERT INTO nation (nationkey, name, regionkey, comment) VALUES (26, 'POLAND', 3, 'no comment'); 在不指定 comment 列的情况下插入单行，该列的值将为 null：
JMX 摘要 SELECT * FROM jmx.current."table_name"; 说明 所有的JMX数据都以表格的形式存储在jmx.current中，其中table_name必须用引号注释。 用户需要先找到存储 JMX 数据的表格，然后使用SELECT语句进行查看。 示例 查看 row data cache 统计数据： SELECT * FROM jmx.current."io.prestosql.orc:name=hive,type=rowdatacachestatslister"; 查看 bloom filter cache 统计数据： SELECT * FROM jmx.current."io.prestosql.orc:name=hive,type=bloomfiltercachestatslister";
PREPARE 摘要 PREPARE statement_name FROM statement 说明 准备一条语句，以便在以后执行。准备的语句是保存在具有给定名称的会话中的查询。该语句可以包含参数以代替字面量，这些参数在执行时被替换为实际的值。参数由问号表示。 示例 准备一个 select 查询： PREPARE my_select1 FROM SELECT * FROM nation; 准备一个包含参数的 select 查询。将与 regionkey 和 nationkey 进行比较的值将通过 execute 语句进行填充： PREPARE my_select2 FROM SELECT name FROM nation WHERE regionkey = ? AND nationkey < ?; 准备一个 insert 查询： PREPARE my_insert FROM INSERT INTO cities VALUES (1, 'San Francisco'); 另请参见 EXECUTE、DEALLOCATE PREPARE、DESCRIBE INPUT、DESCRIBE OUTPUT
REFRESH META CACHE 使用方式 REFRESH META CACHE [FOR CATALOG] 说明 REFRESH META CACHE用于刷新当前目录连接器元数据缓存。REFRESH META CACHE FOR CATALOG用于刷新指定目录连接器元数据缓存。 示例 刷新当前目录连接器元数据缓存 REFRESH META CACHE 刷新指定目录连接器元存储缓存 REFRESH META CACHE FOR catalog 限制 目前仅Hive连接器支持该功能。
RESET SESSION 摘要 RESET SESSION name RESET SESSION catalog.name 说明 将会话属性值重置为默认值。 示例 RESET SESSION optimize_hash_generation; RESET SESSION hive.optimized_reader_enabled; 另请参见 SET SESSION、SHOW SESSION
REVOKE ROLES 摘要 REVOKE [ ADMIN OPTION FOR ] role [, ...] FROM ( user | USER user | ROLE role) [, ...] [ GRANTED BY ( user | USER user | ROLE role | CURRENT_USER | CURRENT_ROLE ) ] 说明 从当前目录中的指定主体回收指定的角色。 如果指定了 ADMIN OPTION FOR 子句，则回收 GRANT 权限，而不是回收角色。 为了使针对角色的 REVOKE 语句成功执行，执行该语句的用户应具有管理员角色或者应对于给定的角色拥有 GRANT 选项。 可选的 GRANTED BY 子句可使指定的主体作为回收方来回收角色。如果未指定 GRANTED BY 子句，则当前用户作为回收方来回收角色。 示例 从用户 foo 回收角色 bar： REVOKE bar FROM USER foo; 从用户 baz 和角色 qux 回收角色 bar 和 foo 的管理员选项：
REVOKE 摘要 REVOKE [ GRANT OPTION FOR ] ( privilege [, ...] | ALL PRIVILEGES ) ON [ TABLE ] table_name FROM ( user | USER user | ROLE role ) 说明 从指定的被授权者回收指定的权限。 指定 ALL PRIVILEGES 可以回收 DELETE、INSERT 和 SELETE 权限。 指定 ROLE PUBLIC 可以从 PUBLIC 角色回收权限。用户将保留直接或通过其他角色分配给他们的权限。 可选的 GRANT OPTION FOR 子句还会回收授予指定权限的权限。 为了使 REVOKE 语句成功执行，执行该语句的用户应拥有指定的权限并且对于这些权限拥有 GRANT OPTION。 示例 从用户 alice 回收对表 orders 的 INSERT 和 SELECT 权限： REVOKE INSERT, SELECT ON orders FROM alice; 从所有用户回收对表 nation 的 SELECT 权限，此外还回收授予 SELECT 权限的权限：
ROLLBACK 摘要 ROLLBACK [ WORK ] 说明 回滚当前事务。 示例 ROLLBACK; ROLLBACK WORK; 另请参见 COMMIT、START TRANSACTION
SELECT 摘要 [ WITH with_query [, ...] ] SELECT [ ALL | DISTINCT ] select_expression [, ...] [ FROM from_item [, ...] ] [ WHERE condition ] [ GROUP BY [ ALL | DISTINCT ] grouping_element [, ...] ] [ HAVING condition] [ { UNION | INTERSECT | EXCEPT } [ ALL | DISTINCT ] select ] [ ORDER BY expression [ ASC | DESC ] [, ...] ] [ OFFSET count [ ROW | ROWS ] ] [ LIMIT { count | ALL } | FETCH { FIRST | NEXT } [ count ] { ROW | ROWS } { ONLY | WITH TIES } ] 其中，from_item有如下两种形式：
SET ROLE 摘要 SET ROLE ( role | ALL | NONE ) 说明 SET ROLE 在当前目录中设置当前会话的启用角色。 SET ROLE role 启用为当前会话指定的单个角色。为了使 SET ROLE role 语句成功执行，执行该语句的用户应该具有给定角色的授予权限。 SET ROLE ALL 启用当前用户在当前会话中被授予的所有角色。 SET ROLE NONE 禁用当前用户在当前会话中被授予的所有角色。 限制 某些连接器不支持角色管理。有关更多详细信息，请参见连接器文档。 另请参见 CREATE ROLE、DROP ROLE、GRANT ROLES、REVOKE ROLES
SET SESSION 摘要 SET SESSION name = expression SET SESSION catalog.name = expression 说明 设置会话属性值。 示例 SET SESSION optimize_hash_generation = true; SET SESSION hive.optimized_reader_enabled = true; 另请参见 RESET SESSION、SHOW SESSION
SHOW CACHE 摘要 SHOW CACHE; 说明 SHOW CACHE 显示分离式缓存协调器元数据。分离式缓存包含有关缓存的表和分区的信息。 示例 显示所有缓存元数据 SHOW CACHE; 显示销售表的缓存元数据 SHOW CACHE sales; 限制 目前只有Hive连接器支持此功能。 有关更多详细信息，请参见连接器文档。 另请参见 CACHE TABLE、DROP CACHE
SHOW CATALOGS 摘要 SHOW CATALOGS [ LIKE pattern ] 说明 列出可用的目录。LIKE 子句可用于限制目录名称列表。
SHOW COLUMNS 摘要 SHOW COLUMNS FROM table 说明 列出 table 中的列及其数据类型和其他属性。
SHOW CREATE CUBE 概要 SHOW CREATE CUBE cube_name 描述 显示创建指定cube的SQL语句。 示例 在orders表上创建cubeorders_cube CREATE CUBE orders_cube ON orders WITH (AGGREGATIONS = (avg(totalprice), sum(totalprice), count(*)), GROUP = (custKEY, ORDERkey), format= 'orc') 运行SHOW CREATE CUBE命令显示用于创建cubeorders_cube的SQL语句： SHOW CREATE CUBE orders_cube; CREATE CUBE orders_cube ON orders WITH (AGGREGATIONS = (avg(totalprice), sum(totalprice), count(*)), GROUP = (custKEY, ORDERkey), format= 'orc')
SHOW CREATE TABLE 摘要 SHOW CREATE TABLE table_name 说明 显示创建指定的表的 SQL 语句。 示例 显示可用于创建 orders 表的 SQL 语句： SHOW CREATE TABLE sf1.orders; Create Table ----------------------------------------- CREATE TABLE tpch.sf1.orders ( orderkey bigint, orderstatus varchar, totalprice double, orderdate varchar ) WITH ( format = 'ORC', partitioned_by = ARRAY['orderdate'] ) (1 row) 另请参见 CREATE TABLE
SHOW CREATE VIEW 摘要 SHOW CREATE VIEW view_name 说明 显示创建指定的视图的 SQL 语句。 另请参见 CREATE VIEW
SHOW EXTERNAL FUNCTION 语法 SHOW EXTERNAL FUNCTION function_name [ ( parameter_type[, ...] ) ] 描述 输出注册在function manager中的external function函数信息。 如果指定输入参数，则输出精准匹配输入类型的 function_name 的函数信息. 例子 例如我们需要显示函数签名为 example.default.format(double, integer)的external function函数信息: show external function example.default.format(double, integer); External Function | Argument Types --------------------------------------------------------------------------------------------------------------------------------------------+----------------- External FUNCTION example.default.format ( | double, integer k double, | h integer | ) | RETURNS varchar | | COMMENT 'format the number ''num'' to a format like''#,###,###.##'', rounded to ''lo'' decimal places, and returns the result as a string' | DETERMINISTIC | RETURNS NULL ON NULL INPUT | EXTERNAL 显示所有函数名称为 example.
SHOW FUNCTIONS 摘要 SHOW FUNCTIONS [ LIKE pattern [ ESCAPE 'escape_character' ] ] 说明 列出所有可以在查询中使用的函数，LIKE 子句可用于限制函数名称列表。 注意 如果需要列出外部函数，请设置会话属性list_built_in_functions_only为false。
SHOW GRANTS 摘要 SHOW GRANTS [ ON [ TABLE ] table_name ] 说明 列出当前用户对当前目录中指定表的权限。 如果未指定表名，该命令将列出当前用户对当前目录的所有模式中所有表的权限。 该命令要求设置当前目录。 注意 在执行任何授权命令之前，确保已启用身份验证。 示例 列出当前用户对表 orders 的权限： SHOW GRANTS ON TABLE orders; 列出当前用户对当前目录的所有模式中所有表的权限： SHOW GRANTS; 限制 某些连接器不支持 SHOW GRANTS。有关更多详细信息，请参见连接器文档。 另请参见 GRANT、REVOKE
SHOW ROLE GRANTS 摘要 SHOW ROLE GRANTS [ FROM catalog ] 说明 非递归地列出向 catalog（如果未指定 catalog，则为当前目录）中的会话用户授予的 ROLE。
SHOW ROLES 摘要 SHOW [CURRENT] ROLES [ FROM catalog ] 说明 SHOW ROLES 列出 catalog（如果未指定 catalog，则为当前目录）中的所有角色。 SHOW CURRENT ROLES 列出已针对 catalog（如果未指定 catalog，则为当前目录）中的会话启用的角色。
SHOW SCHEMAS 摘要 SHOW SCHEMAS [ FROM catalog ] [ LIKE pattern ] 说明 列出 catalog 或当前目录中的模式。LIKE 子句可用于限制模式名称列表。
SHOW SESSION 摘要 SHOW SESSION 说明 列出当前会话属性。 另请参见 RESET SESSION、SET SESSION
SHOW STATS 摘要 SHOW STATS FOR table SHOW STATS FOR ( SELECT * FROM table [ WHERE condition ] ) 说明 返回命名表或（有限）查询结果的近似统计信息。 针对每列返回统计信息并返回一个摘要行。 列 说明 column_name 列的名称（对于摘要行为 NULL） data_size 列中所有值的总大小（以字节为单位） distinct_values_count 列中唯一值的数量 nulls_fractions 列中为 NULL 的值部分 row_count 行数（仅针对摘要行返回） low_value 在该列中找到的最小值（仅适用于某些类型） high_value 在该列中找到的最大值（仅适用于某些类型）
SHOW TABLES 摘要 SHOW TABLES [ FROM schema ] [ LIKE pattern ] 说明 列出schema 或当前模式中的表。LIKE 子句可用于限制表名称列表。
START TRANSACTION 摘要 START TRANSACTION [ mode [, ...] ] 其中 mode 是以下值之一： ISOLATION LEVEL { READ UNCOMMITTED | READ COMMITTED | REPEATABLE READ | SERIALIZABLE } READ { ONLY | WRITE } 说明 为当前会话启动一个新事务。 示例 START TRANSACTION; START TRANSACTION ISOLATION LEVEL REPEATABLE READ; START TRANSACTION READ WRITE; START TRANSACTION ISOLATION LEVEL READ COMMITTED, READ ONLY; START TRANSACTION READ WRITE, ISOLATION LEVEL SERIALIZABLE; 另请参见 COMMIT、ROLLBACK
UPDATE 摘要 UPDATE table_name SET column_name = expression[, column_name = expression, ... ] [ WHERE condition ] 说明 UPDATE 更改满足条件的所有行中指定列的值。只需在 SET 子句中涉及要修改的列；未显式修改的列保持原来的值。 示例 更新表 users，将 id 等于 1 的行中的姓名更改为 Francisco： UPDATE users SET name = 'Francisco' WHERE id=1; 限制 目前只有 Hive 连接器和事务 ORC 表支持UPDATE。 SET 表达式不支持子查询。 支持直接列引用，但不支持带列引用的表达式。 无法将 UPDATE 应用于视图。 UPDATE 不支持隐式数据类型转换，当值与目标列的数据类型不匹配时，请使用 CAST。 如果表进行了分区和/或分桶，则无法更新 bucket 列和 partition 列。也就是说，它们不能是 SET 表达式的目标。 另请参见 INSERT、INSERT OVERWRITE
USE 摘要 USE catalog.schema USE schema 说明 更新会话以使用指定的目录和模式。如果未指定目录，则相对于当前目录解析模式。 示例 USE hive.finance; USE information_schema;
VACUUM 摘要 VACUUM TABLE table_name [FULL [UNIFY]] [PARTITION partition_value]? [AND WAIT]? 说明 大数据系统通常使用 HDFS 进行存储，以实现数据在集群中各个节点之间的持久性、透明分布和均衡。HDFS 是一个不可变的文件系统，其间的数据不可编辑，只能追加。为了使用不可变的文件系统，不同的文件格式采用写入新文件以支持数据突变，随后使用异步后台合并来保持性能并避免产生许多小文件。 例如，在 Hive 连接器中，您可以逐行更新或删除 ORC 事务性表。不过，每当运行更新时，就会在 HDFS 文件系统中生成新的增量和 delete_delta 文件。使用 VACUUM 可以将所有这些小文件合并成一个大文件，并优化并行性和性能。 VACUUM 的类型： 默认 可以将默认 VACUUM 视为合并表的小数据集的第一级。该操作经常发生，通常比 FULL VACUUM 更快。 Hive： 在 Hive 连接器中，默认 VACUUM 对应于“轻量级压缩”。将所有有效的增量目录合并到一个压缩的增量目录中，并类似地将所有有效的 delete_delta 目录合并到一个 delete_delta 目录中。基本文件不会更改。一旦所有读取方都完成了对较小的旧增量文件的读取，就删除这些文件。 FULL 可以将 FULL VACUUM 视为合并表的所有数据集的下一级。与默认 VACUUM 相比，该操作发生的频率更低，完成时间也更长。 FULL UNIFY UNIFY选项有助于将每个分区的多个桶文件合并为单个桶文件，桶号为0。 Hive： 在 Hive 连接器中，FULL VACUUM 对应于“重量级压缩”。将所有基本文件和增量文件合并在一起。作为该操作的一部分，会永久删除已删除或更新的行。会从元存储中的事务表中删除所有中止的事务。一旦所有读取方都完成了对旧增量文件的读取，就删除这些文件。 FULL 关键字表示是否启动重量级压缩。如果没有该选项，它将执行轻量级压缩。 可以使用 PARTITION 子句来指定清理哪个分区。 可以使用 AND WAIT 来指定该 VACUUM 以同步模式运行。如果没有该选项，它将以异步模式运行。
VALUES 摘要 VALUES row [, ...] 其中 row 是单个表达式或 ( column_expression [, ...] ) 说明 定义字面量内联表。 可以在任何可以使用查询的地方（如 SELECT 和 INSERT 语句的FROM 子句甚至是在顶级中）使用 VALUES。VALUES 创建一个不含列名的匿名表，但可以使用带列别名的子句 AS 对表和列进行命名。 示例 返回一个具有一列和三行的表： VALUES 1, 2, 3 返回一个具有两列和三行的表： VALUES (1, 'a'), (2, 'b'), (3, 'c') 返回一个具有列 id 和 name 的表： SELECT * FROM ( VALUES (1, 'a'), (2, 'b'), (3, 'c') ) AS t (id, name) 创建一个具有列 id 和 name 的表： CREATE TABLE example AS SELECT * FROM ( VALUES (1, 'a'), (2, 'b'), (3, 'c') ) AS t (id, name) 另请参见 INSERT、SELECT
