Presto SQL体系化学习

在日常的工作中，使用较多的是Presto，原因是它比Spark快非常多。当然，使用过程中也会遇到一些问题，其中主要的是一些内置函数与Spark SQL存在较大的差异。这里对Presto SQL一个简单的整理。关于Presto的相关内容可以查看先前的文章：开源分布式查询引擎Presto

Presto 数据类型

以下是对Presto支持的一些数据类型的详细介绍：

Boolean
- BOOLEAN：表示真或假的逻辑数据类型。
Integer
- TINYINT：表示8位有符号整数，范围从-128到127。
- SMALLINT：表示16位有符号整数，范围从-32,768到32,767。
- INTEGER：表示32位有符号整数，范围从-2,147,483,648到2,147,483,647。
- BIGINT：表示64位有符号整数，范围从-9,223,372,036,854,775,808到9,223,372,036,854,775,807。
Floating-Point
- REAL：表示IEEE 754单精度浮点数。
- DOUBLE：表示IEEE 754双精度浮点数。
Fixed-Precision
- DECIMAL：表示精确的定点数。
String
- VARCHAR：表示可变长度的字符串。
- CHAR：表示固定长度的字符串。
- VARBINARY：表示二进制字符串。
- JSON：表示JSON文档。
Date and Time
- DATE：表示日期。
- TIME：表示时间。
- TIME WITH TIME ZONE：表示带有时区的时间。
- TIMESTAMP：表示日期和时间。
- TIMESTAMP WITH TIME ZONE：表示带有时区的日期和时间。
- INTERVAL YEAR TO MONTH：表示从年到月的时间间隔。
- INTERVAL DAY TO SECOND：表示从天到秒的时间间隔。
Structural
- ARRAY：表示值的有序列表。
- MAP：表示键值对的集合。
- ROW：表示一组命名的字段。
Network Address
- IPADDRESS：表示IPv4或IPv6地址。
- IPPREFIX：表示IPv4或IPv6网络。
UUID
- UUID：表示通用唯一标识符。
HyperLogLog
- HyperLogLog：用于近似计数唯一值的算法。
- P4HyperLogLog：是HyperLogLog的一种变体。
- KHyperLogLog：是HyperLogLog的一种变体。
SetDigest
- SetDigest：用于近似集合运算的数据类型。
Quantile Digest
- QDigest：用于计算数据流的百分位数或其他任意分位数的数据类型。
T-Digest
- TDigest：用于计算大型数据流的近似百分位数的数据类型。
KLL Sketch
- KLL Sketch：用于计算数据流的近似分位数的数据类型。

Presto SQL语法简介

Presto是一个分布式SQL查询引擎，设计用于查询大规模数据集。它主要用于执行读取操作，如SELECT查询，而不是更新操作，如INSERT，UPDATE或DELETE。支持哪些特定操作可能取决于您的Presto版本以及正在使用的连接器。例如，某些连接器可能会支持额外的操作，而其他连接器则可能不支持。总的来说，确保了解您正在使用的具体Presto环境的功能是很重要的。

Presto SQL DDL（数据定义语言）

用于定义或更改表的结构、索引、触发器等数据库对象。

在Presto SQL中，Catalog、Schema和Table是三个主要的命名空间，每个都表示不同的数据组织层次。

Catalog：在Presto中，catalog对应到数据源。例如，一个catalog可能连接到一个MySQL数据库，另一个catalog可能连接到Hadoop。一个Presto实例可以有多个catalog，每个catalog对应到一个不同的数据源。
Schema：在Presto中，schema相当于其他数据库系统中的database。schema是catalog内部的命名空间，它包含一组tables。一个catalog可以有多个schema。
Table：table是数据的基本存储单元。一个table属于一个特定的schema，包含一系列的列和行。

因此，database在传统的数据库系统中代表一个独立的数据存储单位，可能包含多个tables、views等，而在Presto中，这个概念对应的是schema。

在使用Presto进行查询时，通常需要指定完整的catalog.schema.table格式来引用一个表。例如：

SELECT * FROM catalog.schema.table;

在这个例子中，catalog是你的数据源，schema是你的数据库，table是你的数据表。

SCHEMA:

CREATE SCHEMA: 这个语句用于创建一个新的schema。例如：CREATE SCHEMA schema_name;
ALTER SCHEMA: 用于更重命名schema。例如：ALTER SCHEMA schema_name RENAME TO new_schema_name
DROP SCHEMA: 这个语句用于删除一个已存在的schema。例如：DROP SCHEMA schema_name;

TABLE:

CREATE TABLE: 这个语句用于创建一个新的表。例如：CREATE TABLE table_name (column1 type1, column2 type2, …);
CREATE TABLE AS: 这个语句用于根据一个SELECT查询的结果创建一个新的表。例如：CREATE TABLE table_name AS SELECT column1, column2 FROM another_table;
ALTER TABLE: 这个语句用于修改已存在的表，如添加、删除或重命名列，或者更改表的名称。例如：ALTER TABLE table_name RENAME TO new_table_name;
DROP TABLE: 这个语句用于删除一个已存在的表。例如：DROP TABLE table_name;

VIEW:

CREATE VIEW: 这个语句用于创建一个新的视图。视图是一个数据库对象，是一个存储的SQL查询，可以像表一样被查询。例如：CREATE VIEW view_name AS SELECT column1, column2 FROM table_name;
DROP VIEW: 这个语句用于删除一个已存在的视图。例如：DROP VIEW view_name;

Presto SQL DML（数据操作语言）

以下是SQL中的一些基本数据操作语句的介绍：

DELETE

DELETE语句用于删除表中的记录。你可以通过WHERE子句来指定要删除的记录。例如：

DELETE FROM table_name WHERE condition;

如果不使用WHERE子句，DELETE语句将删除表中的所有记录。

INSERT

INSERT语句用于向表中插入新的记录。你可以指定要插入的列和值，或者通过一个SELECT语句来插入数据。例如：

INSERT INTO table_name (column1, column2) VALUES (value1, value2);
INSERT INTO table_name (column1, column2) SELECT column1, column2 FROM another_table;

SELECT

SELECT语句用于从一个或多个表中查询数据。你可以通过WHERE子句来过滤结果，通过GROUP BY子句来分组结果，通过ORDER BY子句来排序结果。例如：

SELECT column1, column2 FROM table_name WHERE condition GROUP BY column1 ORDER BY column2;

TRUNCATE

TRUNCATE语句用于删除表中的所有记录。不同于DELETE语句，TRUNCATE语句不会记录每个删除的记录的信息，因此通常比DELETE语句更快。例如：

TRUNCATE TABLE table_name;

UPDATE

UPDATE语句用于更新表中的记录。你可以通过SET子句来指定要更新的列和新的值，通过WHERE子句来指定要更新的记录。例如：

UPDATE table_name SET column1 = value1, column2 = value2 WHERE condition;

Presto SQL DCL（数据控制语言）

用于控制不同数据的访问级别的语言，包括授权和撤销。

这些命令主要关于SQL的角色管理和权限控制：

GRANT: GRANT语句用于给用户授予特定的权限。例如，你可以授予一个用户对特定表的选择权限：GRANT SELECT ON table_name TO user_name;
REVOKE: REVOKE语句用于撤销用户的特定权限。例如，你可以撤销一个用户对特定表的选择权限：REVOKE SELECT ON table_name FROM user_name;
SET ROLE: SET ROLE语句用于设置当前会话的角色。例如：SET ROLE role_name;
CREATE ROLE: CREATE ROLE语句用于创建新的角色。例如：CREATE ROLE role_name;
DROP ROLE: DROP ROLE语句用于删除已存在的角色。例如：DROP ROLE role_name;
GRANT ROLES: GRANT ROLES语句用于将一组角色授予一个用户。例如：GRANT role1, role2 TO user_name;
REVOKE ROLES: REVOKE ROLES语句用于从一个用户撤销一组角色。例如：REVOKE role1, role2 FROM user_name;

Presto SQL TCL（事务控制语言）

在Presto SQL中，以下是你询问的命令的介绍：

START TRANSACTION: 该命令用于开始一个新的数据库事务。事务是一个由一个或多个SQL语句组成的序列，这个序列被作为一个整体来执行，即要么全部执行成功，要么全部不执行（如果事务中的某个操作失败，之前在该事务中的所有操作都会被回滚）。在Presto中，你不能使用START TRANSACTION命令，因为Presto不支持事务。
COMMIT: 该命令用于提交一个数据库事务，保存所有自事务开始以来对数据库所做的更改。在Presto中，你不能使用COMMIT命令，因为Presto不支持事务。
ROLLBACK: 该命令用于回滚一个数据库事务，取消所有自事务开始以来对数据库所做的更改。在Presto中，你不能使用ROLLBACK命令，因为Presto不支持事务。

Presto SQL函数与过程

ALTER FUNCTION

用于修改函数的属性，重新定义函数的行为。

以下是一些例子：

ALTER FUNCTION function_name CALL handler_name

CREATE FUNCTION

该命令用于创建新的用户自定义函数。在Presto中，你可以创建标量函数和聚合函数。例如，下面是创建一个标量函数的例子：

CREATE FUNCTION plus(x integer, y integer)
RETURNS integer
LANGUAGE SQL
AS 'SELECT $1 + $2';

DROP FUNCTION

该命令用于删除已存在的用户自定义函数。例如：

DROP FUNCTION IF EXISTS plus(integer, integer);

CALL

CALL命令用于调用一个存储过程。在Presto中，存储过程通常用于执行不能用标准SQL语句表示的操作，如数据清理、数据迁移等。

Presto会话和系统控制

SET SESSION

SET SESSION命令在当前会话中设置一个或多个配置参数的值。例如：

SET SESSION query_max_run_time = '30m';

上述命令将query_max_run_time配置参数的值设置为30分钟。

RESET SESSION

RESET SESSION命令用于重置当前会话中所有配置参数的值为默认值。例如：

RESET SESSION;

USE

USE命令用于设置当前会话的默认catalog和schema。例如：

USE catalog.schema;

DEALLOCATE PREPARE

DEALLOCATE PREPARE命令用于取消预编译的SQL语句。

PREPARE

PREPARE命令用于预编译一个SQL语句，以后可以通过一个标识符来快速执行这个预编译的SQL语句。

Presto查询与分析

ANALYZE: ANALYZE命令用于计算表的统计信息，以便优化查询。例如：ANALYZE table_name;
EXECUTE: EXECUTE命令在Presto中用于执行一个已经准备好的语句。在Presto中，你可以使用PREPARE语句来创建一个已准备好的语句，然后通过EXECUTE命令来执行它。
DESCRIBE: DESCRIBE命令用于显示表的结构，包括列名、数据类型、是否为空等信息。例如：DESCRIBE table_name;
DESCRIBE INPUT: 用于获取存储过程的输入参数的信息。对于已注册的存储过程，你可以使用下列语句来获取输入参数的信息：DESCRIBE INPUT procedure_name
DESCRIBE OUTPUT: 提供了对指定查询产生的输出列的描述。
EXPLAIN: EXPLAIN命令用于显示一个SQL语句的执行计划，这可以帮助理解和优化SQL语句。例如：EXPLAIN SELECT * FROM table_name;
EXPLAIN ANALYZE: EXPLAIN ANALYZE命令用于显示一个SQL语句的执行计划以及实际的执行统计信息。例如：EXPLAIN ANALYZE SELECT * FROM table_name;
SHOW CATALOGS: SHOW CATALOGS命令用于列出可用的catalogs。例如：SHOW CATALOGS;
SHOW COLUMNS: SHOW COLUMNS命令用于列出表的列信息。例如：SHOW COLUMNS FROM table_name;
SHOW CREATE FUNCTION: 在Presto中查看函数的定义，常常使用SHOW FUNCTIONS命令。这个命令可以显示当前环境中所有可用函数的列表。对于函数的具体实现，用户需要查看函数在源代码中的定义。
SHOW CREATE TABLE: SHOW CREATE TABLE命令用于显示创建表的SQL语句。例如：SHOW CREATE TABLE table_name;
SHOW CREATE VIEW: SHOW CREATE VIEW命令用于显示创建视图的SQL语句。例如：SHOW CREATE VIEW view_name;
SHOW FUNCTIONS: SHOW FUNCTIONS命令用于列出可用的函数。例如：SHOW FUNCTIONS;
SHOW GRANTS:这个命令用于列出特定用户在特定模式下的权限。
SHOW ROLE GRANTS: 此命令用于列出当前用户的角色授权。
SHOW ROLES: 这个命令用于列出当前或指定目录中的所有角色。
SHOW SCHEMAS: SHOW SCHEMAS命令用于列出catalog中的schemas。例如：SHOW SCHEMAS FROM catalog_name;
SHOW SESSION: SHOW SESSION命令用于列出当前会话的配置参数。例如：SHOW SESSION;
SHOW STATS: SHOW STATS命令用于显示表的统计信息。例如：SHOW STATS FOR table_name;
SHOW TABLES: SHOW TABLES命令用于列出schema中的表。例如：SHOW TABLES FROM schema_name;
VALUES: VALUES命令用于构造一个行的集合，每个元素都是一个常量表达式。例如：VALUES (expression1, expression2), (expression3, expression4);

Presto SQL函数说明

Presto的内置函数和其他SQL有较大的差异，使用起来要特别注意，以下整理的函数可能与你当前使用Presto的版本不一致。

Logical Operators

包括 AND, OR, NOT，用于组合或反转条件。

Comparison Functions and Operators

包括 =, !=, <, >, <=, >=, 等，用于比较两个值。

Conditional Expressions

包括CASE，IF，NULLIF，COALESCE等，用于基于条件逻辑进行操作。

Lambda Expressions

允许你编写一个小的函数可以在表达式中使用。

在Presto中，Lambda表达式是用于创建匿名函数的一种手段。Lambda表达式可在函数参数中使用，常常配合如 filter(), transform() 或 reduce() 等函数一起使用。Lambda表达式的形式如下：

(x, y, ..., z -> expression)

在这个表达式中，x, y, …, z 是参数列表，箭头 -> 用于分隔参数列表和表达式，expression 是对参数进行操作的表达式。

举几个例子：

将数组中所有元素乘以2:

SELECT transform(array[1, 2, 3], x -> x * 2);  -- 输出：[2, 4, 6]

使用filter函数过滤数组中的元素：

SELECT filter(array[1, 2, 3, 4], x -> x % 2 = 0);  -- 输出：[2, 4]

使用reduce函数计算数组的和：

SELECT reduce(array[1, 2, 3], 0, (s, x) -> s + x, s -> s);  -- 输出：6

在这个reduce例子中，我们使用了两个Lambda表达式：第一个(s, x) -> s + x用于求和，第二个s -> s返回最终结果。初始值为0。

需要注意的是，Presto的Lambda表达式不能在其他表达式之间共享。也就是不能抽取出来作为公共部分重新使用。每个Lambda表达式都必须是自包含的。

另外，Lambda表达式中的变量名不能与查询中的其他列名或别名重复。如果重复，Presto将会抛出异常。

以上就是关于Presto中Lambda表达式的简单介绍，希望对你有所帮助。

Conversion Functions

提供CAST，TRY_CAST等，用于数据类型之间的转换。

在Presto中，CAST 和 TRY_CAST 都是用来进行数据类型转换的功能，但它们之间的行为在转换失败时有所不同。

CAST：它是标准的SQL功能，用于将一个值从一种数据类型转换为另一种数据类型。例如，将字符串转换为整数，或将浮点数转换为布尔值。如果转换不成功，那么CAST会抛出一个异常。

例如：

SELECT CAST('123' AS INTEGER);  -- 成功，输出：123
SELECT CAST('abc' AS INTEGER);  -- 失败，抛出异常

TRY_CAST：这是Presto特有的功能。它的行为与CAST类似，但是在转换失败时不会抛出异常，而是返回NULL。

例如：

SELECT TRY_CAST('123' AS INTEGER);  -- 成功，输出：123
SELECT TRY_CAST('abc' AS INTEGER);  -- 失败，输出：NULL

所以，你如果想在转换失败时避免异常，并且能够容忍NULL值，你应该使用TRY_CAST。如果你希望在转换失败时能够得到异常，那么你应该使用CAST。

Mathematical Functions and Operators

包括加法，减法，乘法，除法和模，以及函数如ROUND，CEILING，FLOOR等。

数学函数

abs(x)：返回x的绝对值。
cbrt(x)：返回x的立方根。
ceil(x) 或 ceiling(x)：向上取整，返回大于或等于x的最小整数。
cosine_similarity(a, b)：返回两个向量a和b之间的余弦相似性。
degrees(x)：将弧度转换为度。
e()：返回欧拉数，即71828。
exp(x)：返回e的x次方。
floor(x)：向下取整，返回小于或等于x的最大整数。
from_base(x, y)：将字符串x从基数y转换为基数10。
ln(x)：返回x的自然对数。
log2(x)：返回以2为底的x的对数。
log10(x)：返回以10为底的x的对数。
mod(x, y)：返回x除以y的余数。
pi()：返回圆周率π，即14159。
pow(x, y) 或 power(x, y)：返回x的y次方。
radians(x)：将度转换为弧度。
rand() 或 random()：返回一个介于0（包含）和1（不包含）之间的伪随机双精度值。
secure_rand() 或 secure_random()：返回一个介于0（包含）和1（不包含）之间的加密安全伪随机双精度值。此值适合用于密码学。
round(x)：四舍五入x到最接近的整数。
sign(x)：如果x为负，则返回-1；如果x为零，则返回0；如果x为正，则返回1。
sqrt(x)：返回x的平方根。
to_base(x, y)：将基数10的数字x转换为基数y的字符串。
truncate(x, y)：将x截断到小数点后y位。
width_bucket(x, y, z, p)：返回一个桶编号，该编号表示x在由y到z的区间内均匀划分的p个桶中的位置。

概率函数计算特定分布下的累积分布函数（CDF）

beta_cdf(alpha, beta, v)：计算Beta分布的累积分布函数（CDF）。参数alpha和beta是Beta分布的形状参数，v是要计算CDF的值。
binomial_cdf(trials, p, successes)：计算二项分布的CDF。参数trials是试验次数，p是每次试验成功的概率，successes是成功次数。
cauchy_cdf(location, scale, v)：计算柯西分布的CDF。参数location和scale分别表示柯西分布的位置参数和尺度参数，v是要计算CDF的值。
chi_squared_cdf(df, v)：计算卡方分布的CDF。参数df表示自由度，v是要计算CDF的值。
f_cdf(df1, df2, v)：计算F分布的CDF。参数df1和df2表示两个自由度，v是要计算CDF的值。
gamma_cdf(shape, scale, v)：计算伽玛分布的CDF。参数shape和scale分别表示伽玛分布的形状参数和尺度参数，v是要计算CDF的值。
laplace_cdf(location, scale, v)：计算拉普拉斯分布的CDF。参数location和scale分别表示拉普拉斯分布的位置参数和尺度参数，v是要计算CDF的值。
normal_cdf(mean, sd, v)：计算正态分布的CDF。参数mean和sd分别表示正态分布的均值和标准差，v是要计算CDF的值。
poisson_cdf(lambda, v)：计算泊松分布的CDF。参数lambda表示泊松分布的率参数，v是要计算CDF的值。
weibull_cdf(alpha, beta, v)：计算韦氏分布的CDF。参数alpha和beta分别表示韦氏分布的形状参数和尺度参数，v是要计算CDF的值。

概率函数，计算特定分布下的累积分布函数的逆函数（Inverse CDF），也叫做分位数函数。

inverse_beta_cdf(alpha, beta, p)：计算Beta分布的逆CDF。参数alpha和beta是Beta分布的形状参数，p是累积概率。
inverse_binomial_cdf(trials, p, p)：计算二项分布的逆CDF。参数trials是试验次数，p是每次试验成功的概率，p是累积概率。
inverse_cauchy_cdf(location, scale, p)：计算柯西分布的逆CDF。参数location和scale分别表示柯西分布的位置参数和尺度参数，p是累积概率。
inverse_chi_squared_cdf(df, p)：计算卡方分布的逆CDF。参数df表示自由度，p是累积概率。
inverse_gamma_cdf(shape, scale, p)：计算伽玛分布的逆CDF。参数shape和scale分别表示伽玛分布的形状参数和尺度参数，p是累积概率。
inverse_f_cdf(df1, df2, p)：计算F分布的逆CDF。参数df1和df2表示两个自由度，p是累积概率。
inverse_laplace_cdf(location, scale, p)：计算拉普拉斯分布的逆CDF。参数location和scale分别表示拉普拉斯分布的位置参数和尺度参数，p是累积概率。
inverse_normal_cdf(mean, sd, p)：计算正态分布的逆CDF。参数mean和sd分别表示正态分布的均值和标准差，p是累积概率。
inverse_poisson_cdf(lambda, p)：计算泊松分布的逆CDF。参数lambda表示泊松分布的率参数，p是累积概率。
inverse_weibull_cdf(alpha, beta, p)：计算韦氏分布的逆CDF。参数alpha和beta分别表示韦氏分布的形状参数和尺度参数，p是累积概率。

统计函数

Wilson置信区间是用于估计具有二项分布的总体参数的置信区间，通常用于样本比例的置信区间计算。

wilson_interval_lower(pos, neg, z)：计算Wilson置信区间的下限。参数pos是成功的次数，neg是失败的次数，z是正态分布的分位数（例如，对于95%的置信区间，z值通常取96）。
wilson_interval_upper(pos, neg, z)：计算Wilson置信区间的上限。参数与 wilson_interval_lower 相同。

三角函数

acos(x)：返回x的反余弦值，结果的单位是弧度，x的范围在-1到1之间。
asin(x)：返回x的反正弦值，结果的单位是弧度，x的范围在-1到1之间。
atan(x)：返回x的反正切值，结果的单位是弧度，x的范围为所有实数。
atan2(y, x)：返回点(x, y)与x轴的夹角，单位为弧度，y和x的范围为所有实数。
cos(x)：返回x的余弦值，x的单位是弧度。
cosh(x)：返回x的双曲余弦值，x的范围为所有实数。
sin(x)：返回x的正弦值，x的单位是弧度。
tan(x)：返回x的正切值，x的单位是弧度。
tanh(x)：返回x的双曲正切值，x的范围为所有实数。

浮点数函数

infinity()：返回正无穷大。
is_finite(x)：如果x是有限的（即，它既不是无穷大也不是NaN），则返回true，否则返回false。
is_infinite(x)：如果x是无穷大（无论正还是负），则返回true，否则返回false。
is_nan(x)：如果x是NaN，返回true，否则返回false。
nan()：返回非数字（NaN）值。

Bitwise Functions

位运算函数

bit_count(x, bits)：返回二进制表示中位值为1的次数。参数x是要进行位计数的值，bits是要考虑的最大位数。
bitwise_and(x, y)：返回x和y的按位与（AND）结果。
bitwise_not(x)：返回x的按位非（NOT）结果。
bitwise_or(x, y)：返回x和y的按位或（OR）结果。
bitwise_xor(x, y)：返回x和y的按位异或（XOR）结果。
bitwise_shift_left(x, shift)：返回x向左移动shift位的结果。如果shift为负，则会移动相反的方向。
bitwise_logical_shift_right(x, shift)：返回x向右逻辑移动shift位的结果。如果shift为负，则会移动相反的方向。
bitwise_arithmetic_shift_right(x, shift)：返回x向右算术移动shift位的结果。如果shift为负，则会移动相反的方向。与逻辑右移不同，算术右移会保留符号位。

位移函数

bitwise_left_shift(x, shift)：返回x向左移动shift位的结果。x是要进行移位的值，shift是移位的位数。如果shift为负，则会移动相反的方向。
bitwise_right_shift(x, shift)：返回x向右逻辑移动shift位的结果。逻辑右移会在左侧插入零。x是要进行移位的值，shift是移位的位数。如果shift为负，则会移动相反的方向。
bitwise_right_shift_ari(x, shift)：返回x向右算术移动shift位的结果。算术右移会保留符号位。x是要进行移位的值，shift是移位的位数。如果shift为负，则会移动相反的方向。

Decimal Functions and Operators

处理十进制数的函数和操作，例如DECIMAL构造函数。DECIMAL构造函数：用于创建一个十进制数。例如，DECIMAL ‘3.14’会创建一个值为3.14的十进制数。

String Functions and Operators

字符串操作

||”操作符是一种字符串连接操作符，它将两个或多个字符串组合成一个单一的字符串。例如，假设我们有两个字符串”Hello”和”World”，我们可以使用”||”操作符将它们连接起来，如下所示：SELECT ‘Hello’ || ‘ ‘ || ‘World’;

字符串函数：

chr(integer)：返回由所给整数表示的Unicode字符。
codepoint(string)：返回字符串中第一个字符的Unicode代码点。
concat(string1, string2, …): 连接两个或更多字符串。
ends_with(string, substring)：如果字符串以子串结束，则返回true。
hamming_distance(string1, string2)：返回两个字符串之间的汉明距离。
length(string)：返回字符串的长度。
levenshtein_distance(string1, string2)：返回两个字符串之间的莱文斯坦距离。
lower(string)：返回全部转换为小写的字符串。
lpad(string, size, fill)：返回通过在左侧添加填充字符串fill，使字符串达到指定长度的新字符串。
ltrim(string)：返回删除了左侧空格的字符串。
replace(string, search)：返回一个由替换了所有出现的搜索字符串的字符串。
replace_first(string, pattern, replacement)：返回一个由替换了第一个匹配模式的字符串。
reverse(string)：返回反转后的字符串。
rpad(string, size, fill)：返回通过在右侧添加填充字符串fill，使字符串达到指定长度的新字符串。
rtrim(string)：返回删除了右侧空格的字符串。
split(string, delimiter)：返回由分隔符分隔的字符串数组。
split_part(string, delimiter, field)：返回由分隔符分隔的字符串的字段。
split_to_map(string, entryDelimiter, keyValueDelimiter)：返回由条目分隔符和键值分隔符分隔的字符串的映射。
split_to_multimap(string, entryDelimiter, keyValueDelimiter)：返回由条目分隔符和键值分隔符分隔的字符串的多重映射。
strpos(string, substring)：返回子串在字符串中第一次出现的位置。
starts_with(string, substring)：如果字符串以子串开始，则返回true。
strrpos(string, substring)：返回子串在字符串中最后一次出现的位置。
position(substring in string)：返回子串在字符串中第一次出现的位置。
substr(string, start, length)：返回字符串的子串。
trim(string)：返回删除了前导和尾随空格的字符串。
upper(string)：返回全部转换为大写的字符串。
word_stem(string, language)：返回字符串的词干。

Unicode函数

normalize(string [, form])：返回在给定的Unicode正规化形式下正规化的字符串。form是一个可选参数，表示正规化形式，可以是”NFC”、”NFD”、”NFKC”、”NFKD”之一。如果不指定form，则默认为”NFC”。
to_utf8(string)：将字符串转换为UTF-8编码的varbinary。
from_utf8(bytes [, replace])：将UTF-8编码的varbinary转换为字符串。replace是一个可选参数，表示在发现无效UTF-8序列时是否应该替换无效字符。如果设置为true，无效字符将被Unicode替换字符（U+FFFD）替换。如果设置为false或省略，函数将在遇到无效UTF-8序列时失败。
key_sampling_percent()：此函数不是一个通用的Unicode函数，它没有明确的应用在Unicode字符串处理中。

Regular Expression Functions

正则表达式是用于处理字符串的强大工具，它有一套复杂的语法和一系列的函数可以帮助我们处理和操作字符串。下面是一些常见的正则表达式函数的介绍：

regexp_extract_all(string, pattern): 这个函数返回一个数组，该数组包含了所有匹配到的子字符串。如果没有匹配到任何子字符串，它将返回一个空数组。
regexp_extract(string, pattern, index): 这个函数返回第一个匹配到的子字符串。如果没有匹配到任何子字符串，它将返回NULL。index参数表示返回匹配到的第几个子字符串，索引从1开始。
regexp_like(string, pattern): 这个函数返回一个布尔值，表示字符串是否匹配给定的模式。如果字符串匹配模式，它将返回true，否则返回false。
regexp_replace(string, pattern, replacement): 这个函数返回一个新字符串，该字符串是通过将原始字符串中匹配到的所有子字符串替换为replacement得到的。如果没有匹配到任何子字符串，它将返回原始字符串。
regexp_split(string, pattern): 这个函数返回一个数组，该数组是通过将字符串按照匹配到的模式分割得到的。如果没有匹配到任何模式，它将返回一个只包含原始字符串的单元素数组。

Binary Functions and Operators

以下是一些常见的二进制函数及其描述：

to_base64() 和 from_base64(): 将二进制数据转换为Base64字符串和从Base64字符串转换回二进制数据。
to_base64url() 和 from_base64url(): 将二进制数据转换为Base64Url安全的字符串和从Base64Url安全的字符串转换回二进制数据。
to_base32() 和 from_base32(): 将二进制数据转换为Base32字符串和从Base32字符串转换回二进制数据。
to_hex() 和 from_hex(): 将二进制数据转换为十六进制字符串和从十六进制字符串转换回二进制数据。
to_big_endian_64() 和 from_big_endian_64(): 将64位整数转换为大端字节序的二进制数据，以及从大端字节序的二进制数据转换回64位整数。
to_big_endian_32() 和 from_big_endian_32(): 将32位整数转换为大端字节序的二进制数据，以及从大端字节序的二进制数据转换回32位整数。
to_ieee754_32() 和 from_ieee754_32(): 将32位浮点数转换为IEEE 754标准形式的二进制数据，以及从IEEE 754标准形式的二进制数据转换回32位浮点数。
to_ieee754_64() 和 from_ieee754_64(): 将64位浮点数转换为IEEE 754标准形式的二进制数据，以及从IEEE 754标准形式的二进制数据转换回64位浮点数。
crc32(): 计算数据的CRC32校验和。
md5(): 计算数据的MD5哈希值。
murmur3_x64_128(): 计算数据的MurmurHash3哈希值。
sha1(), sha256(), sha512(): 计算数据的SHA-1, SHA-256, SHA-512哈希值。
xxhash64(): 计算数据的XXHash哈希值。
spooky_hash_v2_32() 和 spooky_hash_v2_64(): 计算数据的SpookyHash哈希值。
hmac_md5(), hmac_sha1(), hmac_sha256(), hmac_sha512(): 使用HMAC方法（使用MD5, SHA-1, SHA-256, SHA-512）计算数据的哈希值。

这些函数主要用于数据的编码、解码、哈希和校验等操作。

JSON Functions and Operators

Cast to JSON与Cast from JSON

Cast to JSON: 这个操作是将其他数据类型转换为JSON格式。这通常在你需要将数据存储为JSON格式或者将数据发送到一个接收JSON数据的服务时使用。例如，你可能有一个包含多个字段的数据，你可以将这个数据转换为一个JSON对象，这样你就可以在一个单一的JSON对象中访问所有的字段。SELECT CAST(‘{“name”: “John”, “age”: 30}’ AS JSON);上述SQL语句将一个字符串转换为JSON对象。
Cast from JSON: 这个操作是将JSON格式的数据转换为其他数据类型。这通常在你接收到一个JSON数据，并需要将它转换为你的应用程序可以更容易处理的格式时使用。例如，你可以将一个包含姓名和年龄的JSON对象转换为一个可以直接访问姓名和年龄字段的数据类型。SELECT CAST(‘{“name”: “John”, “age”: 30}’ AS JSON)->>’name’;

JSON函数

在处理JSON数据时，以下是一些常用的JSON函数及其描述：

is_json_scalar(json_value): 返回一个布尔值，表示给定的JSON值是否为标量（即，是否为字符串、数字、布尔值或null）。
json_array_contains(json_array, value): 返回一个布尔值，表示JSON数组是否包含给定的值。
json_array_get(json_array, index): 返回JSON数组中给定索引的值。索引从零开始。
json_array_length(json_array): 返回JSON数组的长度。
json_extract(json, path): 使用给定的路径从JSON值中提取数据。路径是由字符串、数字和两个特殊关键字（’.’和’*’）组成的表达式。
json_extract_scalar(json, path): 类似于json_extract()，但它将结果转换为标量值。
json_format(json): 返回一个人类可读的字符串，它表示给定的JSON值。
json_parse(json_string): 将字符串解析为JSON值。
json_size(json): 返回JSON值的大小（以字节为单位）。

每个函数都有其特定的作用和返回类型。在处理JSON数据时，可能需要一种或多种这样的函数。

Date and Time Functions and Operators

日期和时间操作符

日期和时间操作符在SQL和许多其他编程语言中都非常常见。它们用于执行日期和时间的各种运算，例如比较、加减、提取特定部分等。以下是一些常见的日期和时间操作符：

+ 和 –

加法和减法运算可以用来将天数、月数或年数加到日期上，或从日期中减去。例如：

SELECT DATE '2022-01-01' + INTERVAL '1' DAY;  -- 返回 '2022-01-02'
SELECT DATE '2022-01-01' - INTERVAL '1' DAY;  -- 返回 '2021-12-31'

–: 用于比较两个日期之间的差异。例如：

SELECT DATE '2022-01-01' - DATE '2021-01-01';  -- 返回365，代表两个日期之间的天数差

时区转换

时区转换是在处理日期和时间数据时常见的需求。许多数据库提供了处理时区的内置功能。以下是一些常见的时区转换方法：

AT TIME ZONE 关键字：这是进行时区转换的通用方法，它将一个日期或时间戳从一个时区转换到另一个时区。例如，在PostgreSQL中，你可以这样使用：

SELECT TIMESTAMP '2022-01-01 00:00:00' AT TIME ZONE 'UTC' AT TIME ZONE 'America/New_York';

这将UTC时区的时间转换为New York时区的时间。

CONVERT_TZ 函数：在MySQL中，你可以使用这个函数来进行时区转换：

SELECT CONVERT_TZ('2022-01-01 00:00:00','UTC','America/New_York');

date_add 或 date_sub 函数：如果你知道时区之间的时间差，你也可以使用这些函数来手动更改时间。例如，如果你知道New York比UTC时间晚5小时，你可以这样做：

SELECT DATE_ADD('2022-01-01 00:00:00', INTERVAL 5 HOUR);

注意，具体的函数和关键字可能因不同的数据库系统而异，所以在使用时需要查阅相应的数据库文档。同时，由于夏令时的影响，时区之间的差异可能会有所改变，因此在处理不同时区的数据时需要特别注意。

日期/时间函数

current_timezone(): 返回当前的时区。
date(): 返回当前日期或将给定的日期/时间戳转换为日期。
last_day_of_month(): 返回给定日期所在月份的最后一天的日期。
from_iso8601_timestamp(): 将ISO 8601格式的字符串转换为时间戳。
from_iso8601_date(): 将ISO 8601格式的字符串转换为日期。
from_unixtime(): 将UNIX时间戳（即，自1970年1月1日以来的秒数）转换为日期/时间字符串。
now(): 返回当前的日期和时间。
to_iso8601(): 将日期或时间戳转换为ISO 8601格式的字符串。
to_milliseconds(): 将日期或时间戳转换为自1970年1月1日以来的毫秒数。
to_unixtime(): 将日期或时间戳转换为UNIX时间戳（即，自1970年1月1日以来的秒数）。

日期/时间截取函数

date_trunc() 是一种在 Presto SQL 中使用的函数，用于截断日期或时间戳字段到指定的单位。这意味着在指定的单位之后的所有字段都将变为零。

格式如下：

date_trunc('interval', timestamp)

在这里，’interval’ 是你想要截断的日期或时间的级别，比如 ‘year’, ‘quarter’, ‘month’, ‘day’ 等。’timestamp’ 是你想要截断的日期或时间戳。

例如，如果你有一个日期 ‘2022-12-31’，并且你使用 date_trunc(‘year’, date)，结果将是 ‘2022-01-01’，因为它会截断日期到年份，把月和日都设为最小单位。

下面是一个具体的例子：

SELECT date_trunc('month', DATE '2022-12-31');

上述查询的结果将是 ‘2022-12-01’，因为 date_trunc() 函数截断日期到月份，把日设为月份的第一天。

日期/时间间隔函数

Presto SQL 中的 date_add() 和 date_diff() 是用于操作日期和时间的函数。以下是它们的定义和使用案例：

date_add()

此函数用于将特定的时间间隔添加到日期或时间戳上。

格式如下：

date_add('unit', interval, timestamp)

在这里，’unit’ 是你想要添加的时间单位（如 ‘day’, ‘hour’, ‘minute’, ‘second’ 等）， ‘interval’ 是你想要添加的量， ‘timestamp’ 是你想要更改的日期或时间戳。

例如：

SELECT date_add('day', 3, DATE '2022-01-01');

上述查询的结果将是 ‘2022-01-04’，因为我们添加了3天。

date_diff()

此函数用于计算两个日期或时间戳之间的差异。

格式如下：

date_diff('unit', timestamp1, timestamp2)

在这里，’unit’ 是你想要得到差异的时间单位（如 ‘day’, ‘hour’, ‘minute’, ‘second’ 等）， ‘timestamp1’ 和 ‘timestamp2’ 是你想要比较的日期或时间戳。

例如：

SELECT date_diff('day', DATE '2022-01-01', DATE '2022-01-04');

上述查询的结果将是 ‘3’，因为两个日期相差3天。

持续时间函数

parse_duration() 是 Presto SQL 中的一个函数，用于将 ISO 8601 持续时间格式的字符串解析为 Presto 的间隔。

Presto的 parse_duration() 函数会自动将解析的间隔转换为 Presto 内部可处理的最小时间单位。例如，如果你解析一个表示几个小时和分钟的持续时间，你得到的结果将是以毫秒为单位的间隔。

MySQL日期函数

在Presto SQL中，date_format() 和 date_parse() 函数用于处理日期和时间，这些函数的工作方式类似于MySQL中的同名函数。以下是它们的定义和使用方法：

date_format()

此函数用于将日期或时间戳格式化为指定的格式。

格式如下：

date_format(timestamp, format)

在这里，’timestamp’ 是你要格式化的日期或时间戳，’format’ 是你希望的输出格式。

例如：

SELECT date_format(TIMESTAMP '2022-01-01 13:15:36 UTC', '%Y-%m-%d %H:%i:%s');

上述查询将返回字符串 ‘2022-01-01 13:15:36’。

date_parse()

此函数用于将字符串解析为日期或时间戳。

格式如下：

date_parse(string, format)

在这里，’string’ 是你想要解析的日期或时间的字符串，’format’ 是字符串的格式。

例如：

SELECT date_parse('2022-01-01 13:15:36', '%Y-%m-%d %H:%i:%s');

上述查询将返回一个日期时间戳 ‘2022-01-01 13:15:36.000 UTC’。

记住，你需要根据你的日期/时间字符串的实际格式调整格式字符串（’%Y-%m-%d %H:%i:%s’）。例如，如果你的日期字符串是 “2022/01/01″，你应该使用 “%Y/%m/%d” 作为格式化字符串。

JAVA日期函数

在 Presto SQL 中，format_datetime() 和 parse_datetime() 函数用于处理日期和时间的格式。以下是它们的定义和使用方法：

format_datetime()

此函数用于将日期或时间戳格式化为指定的格式。

格式如下：

format_datetime(timestamp, format)

在这里，’timestamp’ 是你要格式化的日期或时间戳，’format’ 是你希望的输出格式。

例如：

SELECT format_datetime(TIMESTAMP '2022-01-01 13:15:36 UTC', 'yyyy-MM-dd HH:mm:ss');

上述查询将返回字符串 ‘2022-01-01 13:15:36’。

parse_datetime()

此函数用于将字符串解析为日期或时间戳。

格式如下：

parse_datetime(string, format)

在这里，’string’ 是你想要解析的日期或时间的字符串，’format’ 是字符串的格式。

例如：

SELECT parse_datetime('2022-01-01 13:15:36', 'yyyy-MM-dd HH:mm:ss');

上述查询将返回一个日期时间戳 ‘2022-01-01 13:15:36.000 UTC’。

记住，你需要根据你的日期/时间字符串的实际格式调整格式字符串（’yyyy-MM-dd HH:mm:ss’）。例如，如果你的日期字符串是 “2022/01/01″，你应该使用 “yyyy/MM/dd” 作为格式化字符串。

提取函数

extract() 是一个在Presto SQL中非常有用的函数，它允许你从日期或时间列中提取特定的单位。

其语法非常直观：

extract(unit FROM expression)

unit 是你希望从日期或时间中提取的部分。它可以是 YEAR（年份），QUARTER（季度），MONTH（月份），WEEK（周），DAY（日），HOUR（小时），MINUTE（分钟），SECOND（秒）等。

expression 是你希望从中提取 unit 的日期或时间列。

以下是如何使用它的示例：

SELECT extract(MONTH FROM date_column) as month
FROM table_name;

在上述的SQL查询中，extract() 函数用于从 table_name 表的 date_column 字段中提取月份。结果别名为 month。这将返回表中每个记录的日期的月份部分。

Presto SQL提供了一系列便利的提取函数（Convenience Extraction Functions），使我们能够更直观地从日期/时间表达式中提取特定的部分。以下是这些函数的一些示例：

day(expression) 或 day_of_month(expression): 从日期/时间表达式中提取日。
day_of_week(expression) 或 dow(expression): 从日期/时间表达式中提取星期几（1表示星期一，7表示星期日）。
day_of_year(expression) 或 doy(expression): 从日期/时间表达式中提取一年中的第几天（1-366）。
hour(expression): 从日期/时间表达式中提取小时（0-23）。
millisecond(expression): 从日期/时间表达式中提取毫秒。
minute(expression): 从日期/时间表达式中提取分钟（0-59）。
month(expression): 从日期/时间表达式中提取月份（1-12）。
quarter(expression): 从日期/时间表达式中提取季度（1-4）。
second(expression): 从日期/时间表达式中提取秒（0-59）。
timezone_hour(expression): 从日期/时间表达式中提取时区的小时部分。
timezone_minute(expression): 从日期/时间表达式中提取时区的分钟部分。
week(expression) 或 week_of_year(expression): 从日期/时间表达式中提取一年中的第几周（1-53）。
year(expression): 从日期/时间表达式中提取年份。
year_of_week(expression) 或 yow(expression): 从日期/时间表达式中提取周年（在周年结束时年份增加）。

请注意，这些函数的输入 expression 应该是日期/时间类型的列或表达式。

Aggregate Functions

特殊聚合函数array_agg()

array_agg() 是 Presto SQL 中的一个聚合函数，它用于将多个输入值合并成一个数组。如果你想要对输入值进行排序，你可以使用 ORDER BY 子句。这在你希望结果数组按特定顺序返回时非常有用。

array_agg(x ORDER BY y DESC)

这个函数会收集 x 的值，并根据 y 的值以降序方式进行排序。换句话说，y 的最大值将出现在结果数组的开头。

例如：

SELECT array_agg(name ORDER BY age DESC) as names
FROM people;

该查询将返回一个包含所有人名的数组，数组中的名字按照对应人的年龄降序排列。

array_agg(x ORDER BY x, y, z)

这个函数会收集 x 的值，并首先根据 x 自身的值进行排序，如果 x 的值相同，则继续根据 y 的值进行排序，如果 y 的值也相同，则根据 z 的值进行排序。

例如：

SELECT array_agg(name ORDER BY name, age, city) as names
FROM people;

该查询将返回一个包含所有人名的数组，数组中的名字首先按照名字本身进行排序，如果名字相同，则按照年龄排序，如果年龄也相同，则按照城市进行排序。

通用聚合函数

Presto SQL 提供了许多通用的聚合函数，下面是它们的简要介绍：

any_value(): 返回输入列中的任意值。
arbitrary(): 返回输入列中的任意值。
array_agg(): 收集所有输入值并返回一个数组。
avg(): 计算输入列的平均值。
bool_and(): 如果所有输入值都为TRUE，则返回TRUE，否则返回FALSE。
bool_or(): 如果任何输入值为TRUE，则返回TRUE，否则返回FALSE。
checksum(): 返回输入列的校验和。
count(): 计算输入列的行数。
count_if(): 计算满足特定条件的输入列的行数。
every(): 如果所有输入值都为TRUE，则返回TRUE，否则返回FALSE。
geometric_mean(): 计算输入值的几何平均数。
max_by(): 返回使某列最大化的输入列的值。
min_by(): 返回使某列最小化的输入列的值。
max(): 返回输入列的最大值。
min(): 返回输入列的最小值。
reduce_agg(): 对输入列应用reduce函数以生成一个结果。
set_agg(): 返回输入列的集合。
set_union(): 返回所有输入集合的并集。
sum(): 计算输入列的总和。

每个函数都有其特定的用途，可以满足不同的数据分析需求。在使用时，你需要根据所处理的数据类型和特定的分析目标来选择合适的函数。

位运算聚合函数

在 Presto SQL 中，你可以使用特定的位运算聚合函数来对输入值执行位运算。下面是它们的简要介绍：

bitwise_and_agg(): 对所有输入数值执行位与运算。它将每一个输入值视为二进制数，并执行 AND 运算。只有所有值的某位都是 1，结果的这一位才是 1。
bitwise_or_agg(): 对所有输入数值执行位或运算。它将每一个输入值视为二进制数，并执行 OR 运算。只要有一个值的某位是 1，结果的这一位就是 1。
bitwise_xor_agg(): 对所有输入数值执行位异或运算。它将每一个输入值视为二进制数，并执行 XOR 运算。如果某位上的输入值有奇数个 1，结果的这一位就是 1；如果有偶数个 1，结果的这一位就是 0。

以下是一些示例：

SELECT bitwise_and_agg(column) FROM table;  -- 对 'column' 列所有值执行位与运算
SELECT bitwise_or_agg(column) FROM table;  -- 对 'column' 列所有值执行位或运算
SELECT bitwise_xor_agg(column) FROM table;  -- 对 'column' 列所有值执行位异或运算

这些函数通常在需要对二进制数值执行位运算的场景中使用。

针对Map类型数据的聚合函数

Presto SQL 提供了一些针对Map类型数据的聚合函数。以下是这些函数的简要介绍：

histogram(): 这个函数接受一个列名作为输入，返回一个 map，其中的键是列中出现的不同值，值是这些不同值出现的次数。这可以用来快速生成直方图。
map_agg(): 这个函数接受两个列名作为输入，生成一个 map，其中的键是第一个列中的值，值是第二个列中的值。
map_union(): 这个函数接受一个 map 类型的列名作为输入，返回一个 map，其中包含输入所有 map 的并集。如果同一个键在多个 map 中出现，返回的 map 中此键的值会是这些 map 中此键的值的任意一个。
map_union_sum(): 这个函数接受一个 map 类型的列名作为输入，返回一个 map，其中包含输入所有 map 的并集。如果同一个键在多个 map 中出现，返回的 map 中此键的值会是这些 map 中此键的值的总和。
multimap_agg(): 这个函数接受两个列名作为输入，生成一个 map，其中的键是第一个列中的值，值是第二个列中的值组成的数组。

以下是一些使用示例：

SELECT histogram(column) FROM table;  -- 生成 'column' 列值的直方图
SELECT map_agg(key_column, value_column) FROM table;  -- 根据 'key_column' 和 'value_column' 生成 map
SELECT map_union(map_column) FROM table;  -- 计算 'map_column' 的并集
SELECT map_union_sum(map_column) FROM table;  -- 计算 'map_column' 的并集并对重复键的值求和
SELECT multimap_agg(key_column, value_column) FROM table;  -- 根据 'key_column' 和 'value_column' 生成 map，值为数组

这些函数在处理 Map 类型数据时非常有用，可以帮助你更有效地分析和理解数据。

近似聚合函数

这些是 Presto 中的一些近似聚合函数，它们用于在计算效率和精确度之间达到一种权衡。

approx_distinct()

这个函数用于计算一列中不同值的近似数量。这是一个优化过的操作，比去重后的计数要快得多，但是结果可能不是完全准确的。例子：

SELECT approx_distinct(user_id) FROM visits;

此查询将返回访问的近似唯一用户数。

approx_percentile()

函数返回指定百分位的近似值。比如 approx_percentile(x, 0.5) 将计算 x 列的中位数。可以用于找到数值的近似分布。例子：

SELECT approx_percentile(duration, 0.95) FROM calls;

此查询将返回呼叫持续时间的95th百分位数。

numeric_histogram()

这个函数创建一个数值的直方图，可用于可视化数据的分布。你需要指定桶（bin）的数量作为函数的第一个参数。例子：

SELECT numeric_histogram(10, score) FROM reviews;

此查询将返回评论分数的直方图，分数被划分为10个桶。

noisy_count_gaussian()

这个函数返回数据集的大小，并添加了满足高斯分布的噪声以保护隐私。例子：

SELECT noisy_count_gaussian(user_id) FROM visits;

此查询将返回添加了高斯噪声的近似访问用户数。

noisy_count_if_gaussian()

这个函数添加了高斯噪声的计数，但只有在满足特定条件的行才被计数。例子：

SELECT noisy_count_if_gaussian(user_id, duration > 10) FROM visits;

此查询将返回访问持续时间超过10分钟的用户数，并添加了高斯噪声。

noisy_sum_gaussian()

这个函数返回列的和，并添加了满足高斯分布的噪声，以保护隐私。例子：

SELECT noisy_sum_gaussian(sales) FROM transactions;

此查询将返回总销售额，并添加了高斯噪声。

这些函数都为大数据场景提供了有用的工具，可以在短时间内提供可接受的近似结果。

统计聚合函数

下面是Presto SQL中这些统计聚合函数的详细解释：

corr(column1, column2): 计算column1和column2之间的皮尔逊相关系数。
covar_pop(column1, column2): 计算column1和column2之间的总体协方差。
covar_samp(column1, column2): 计算column1和column2之间的样本协方差。
entropy(column): 计算指定列中概率分布的香农熵。
kurtosis(column): 计算指定列的峰度（四阶中心矩）。
regr_intercept(column1, column2): 对column1和column2进行线性回归，并返回截距。
regr_slope(column1, column2): 对column1和column2进行线性回归，并返回斜率。
regr_avgx(column1, column2): 对column1和column2进行线性回归，并返回column1的平均值。
regr_avgy(column1, column2): 对column1和column2进行线性回归，并返回column2的平均值。
regr_count(column1, column2): 对column1和column2进行线性回归，并返回非null对的数量。
regr_r2(column1, column2): 对column1和column2进行线性回归，并返回决定系数(R-squared)。
regr_sxy(column1, column2): 对column1和column2进行线性回归，并返回协方差。
regr_syy(column1, column2): 对column1和column2进行线性回归，并返回column2的平方误差。
regr_sxx(column1, column2): 对column1和column2进行线性回归，并返回column1的平方误差。
skewness(column): 计算指定列的偏度（三阶中心矩）。
stddev(column) 或 stddev_samp(column): 计算指定列的样本标准差。
stddev_pop(column): 计算指定列的总体标准差。
variance(column) 或 var_samp(column): 计算指定列的样本方差。
var_pop(column): 计算指定列的总体方差。

这些函数非常有用，它们可以在SQL查询中进行复杂的统计计算。

数据分类聚合函数

Presto 提供了一系列有关分类度量的聚合函数，用于评估分类模型的性能。以下是它们的详细解释：

classification_miss_rate(buckets, y, y_hat): 误分类率（Miss Rate）是被错误分类的实例在所有实例中的比例。这个函数需要三个参数：buckets 是分组列，y 是实际的标签列，y_hat 是预测的标签列。
classification_fall_out(buckets, y, y_hat): 假正例率（Fall Out）也称为假阳性率，是实际为负例但被错误地预测为正例的实例在所有负例中的比例。这个函数的参数与 classification_miss_rate 相同。
classification_precision(buckets, y, y_hat): 精确率（Precision）也称为查准率，是被正确预测为正例的实例在所有被预测为正例的实例中的比例。这个函数的参数与上述两个函数相同。
classification_recall(buckets, y, y_hat): 召回率（Recall）也称为查全率，是被正确预测为正例的实例在所有实际为正例的实例中的比例。这个函数的参数与上述函数相同。
classification_threshold(buckets, y, y_hat): 这个函数有待补充完整，如果是用于计算阈值的话，通常情况下，阈值是用于将连续变量转化为二元变量的分界点。

例如，你可以运行以下查询来计算一个分类模型的误分类率：

SELECT classification_miss_rate(buckets, actual_label, predicted_label) FROM predictions;

在这个例子中，buckets 是分组列（可能是数据集的一个子集），actual_label 是真实的分类标签，predicted_label 是模型预测的分类标签。

差分熵函数

differential_entropy(bucket_count, sample, weight)

其中，bucket_count 是分桶数，sample 是样本数，weight 是权重。这是一个估计差分熵的函数。在信息论中，差分熵用于描述连续随机变量的随机性或混乱程度。

approx_most_frequent(buckets, value)

这个函数返回元组 (value, frequency)，其中 value 是出现次数最多的值，frequency 是该值出现的频率。buckets 是用于分组的列，value 是要计算频率的列。

蓄水池抽样函数

reservoir_sample() 是 Presto SQL 中的一个蓄水池抽样函数。蓄水池抽样是一种随机抽样方法，特别适用于从不知道大小的（或非常大的）数据集中抽取固定数量的样本。这种抽样方法保证每个元素被抽取的概率都是相等的。

reservoir_sample() 函数的使用方法如下：

reservoir_sample(max_samples, value)

其中，max_samples 是你想要抽取的样本数量，value 是你要从中抽取样本的列。

例如，如果你想从一个包含数百万行的大表中随机抽取 1000 行，你可以像下面这样使用 reservoir_sample() 函数：

SELECT reservoir_sample(1000, value) FROM large_table;

在上面的查询中，value 列的 1000 个随机样本将被抽取出来。

这个函数在处理大数据集时非常有用，因为它可以在固定、有限的内存下工作，而不需要知道数据集的实际大小。

Window Functions

聚合函数

在 SQL 中，聚合函数是对一组值进行操作并返回单个值的函数，例如 SUM(), AVG(), COUNT(), MIN() 和 MAX() 等。当你添加 OVER 子句时，这些聚合函数就变成了窗口函数。窗口函数允许你在一个数据子集（窗口）上进行计算，而非整个结果集。

你给出的查询示例：

SELECT clerk, orderdate, orderkey, totalprice,
       sum(totalprice) OVER (PARTITION BY clerk
                             ORDER BY orderdate) AS rolling_sum
FROM orders
ORDER BY clerk, orderdate, orderkey

在这个查询中，sum(totalprice) OVER (PARTITION BY clerk ORDER BY orderdate) 是一个窗口函数。它计算了每个 clerk（通过 PARTITION BY 子句定义）的 totalprice 的累计和（通过 ORDER BY 子句定义）。这个窗口对每个 clerk 的每一天都重新计算，因此它会给出一个滚动总和（或累计和）。

PARTITION BY 子句将数据分为多个分区，每个分区都有自己的窗口。在这个例子中，每个 clerk 都有自己的分区。

ORDER BY 子句定义了每个分区内的行顺序。在这个例子中，每个 clerk 分区内的行按 orderdate 排序。

所以，这个查询会返回一个表，其中包含每个订单的 clerk，orderdate，orderkey，totalprice，以及到当前日期为止的 clerk 的 totalprice 的滚动总和。

排序函数

在 SQL 中，排名函数是一种特殊类型的窗口函数，用于对结果集中的行进行排序或排名。以下是你提到的几个 Presto SQL 中的排名函数及其用途：

cume_dist(): 计算当前行在其窗口分区内的累积分布。结果是一个介于 0 和 1 之间的值，其中 1 表示当前行不小于分区中的任何行。
dense_rank(): 为窗口分区内的每一行分配一个排名，排名值在整个分区内是连续的。排名相等的行（即，根据 ORDER BY 子句排序结果相同的行）会得到相同的排名。
ntile(n): 将窗口分区内的行分成 n 个大致相等的组，为每一行分配一个 tile（分组）号。例如，ntile(4) 会将结果集划分为四分之一。
percent_rank(): 计算当前行在其窗口分区内的百分比排名。结果是一个介于 0（表示第一名）和 1（表示最后一名）之间的值。
rank(): 为窗口分区内的每一行分配一个排名。排名相等的行（即，根据 ORDER BY 子句排序结果相同的行）会得到相同的排名。如果存在排名相等的行，则下一个排名值会跳过。
row_number(): 为窗口分区内的每一行分配一个唯一的序号。即使多行的排序结果相同，序号也会各不相同。

注意，所有这些函数都需要配合 OVER 子句使用，可以包含 PARTITION BY 和 ORDER BY 来定义窗口分区和排序。例如：

SELECT product, sales, RANK() OVER (ORDER BY sales DESC) as rank
FROM sales_table;

这个查询会返回一个表，其中包含每个产品的销售额，以及它们按销售额降序排名的排名。

值函数

在 SQL 中，值函数是一种窗口函数，它允许你获取窗口内特定位置的值。以下是你提到的一些 Presto SQL 中的值函数及其作用：

first_value(): 返回窗口分区内的第一个值。例如，first_value(sales) OVER (ORDER BY date) 将返回每个窗口中日期最早的销售额。
last_value(): 返回窗口分区内的最后一个值。例如，last_value(sales) OVER (ORDER BY date) 将返回每个窗口中日期最晚的销售额。
nth_value(n): 返回窗口分区内的第 n 个值。例如，nth_value(sales, 3) OVER (ORDER BY date) 将返回每个窗口中日期第三早的销售额。
lead(): 返回当前行之后的行的值。例如，lead(sales) OVER (ORDER BY date) 将返回当前行日期之后的销售额。你还可以指定一个偏移量和默认值，例如 lead(sales, 2, 0) OVER (ORDER BY date) 将返回两行之后的销售额，如果没有那么多行，则返回 0。
lag(): 返回当前行之前的行的值。例如，lag(sales) OVER (ORDER BY date) 将返回当前行日期之前的销售额。你还可以指定一个偏移量和默认值，例如 lag(sales, 3, 0) OVER (ORDER BY date) 将返回三行之前的销售额，如果没有那么多行，则返回 0。

这些函数在分析数据时非常有用，因为它们允许你在同一行中访问其他行的值。然而，它们的结果可能会受窗口大小和偏移量的影响，所以在使用时需要注意定义这些参数。

Array Functions and Operators

在 Presto SQL 中，你可以使用特定的操作符来处理数组类型的数据。

下标操作符 []

这个操作符用于访问数组中的一个元素，数组的索引从 1 开始。例如：

SELECT my_array[1] AS first_element

这个查询将返回 my_array 数组的第一个元素。

连接操作符 ||

这个操作符用于连接两个数组，或者一个数组和一个相同类型的元素。例如：

SELECT ARRAY [1] || ARRAY [2]; -- 结果是: [1, 2]
SELECT ARRAY [1] || 2; -- 结果是: [1, 2]
SELECT 2 || ARRAY [1]; -- 结果是: [2, 1]

这些查询分别演示了如何使用 || 操作符来连接两个数组，以及如何将元素添加到数组的开始或结束。

这些操作符可以帮助你更方便地在 SQL 查询中处理数组数据。

数组函数

在 Presto SQL 中，提供了一系列的数组函数来帮助你处理数组类型的数据。以下是你所提到的这些函数的简要介绍：

all_match(array(T), function(T,boolean)): 判断数组中的所有元素是否都满足指定的条件。
any_match(array(T), function(T,boolean)): 判断数组中是否有任何元素满足指定的条件。
array_average(array(T)): 计算数组中所有元素的平均值。
array_cum_sum(array(T)): 计算数组元素的累积和。
array_distinct(array(T)): 移除数组中的重复元素。
array_duplicates(array(T)): 返回数组中的重复元素。
array_except(array1(T), array2(T)): 返回在第一个数组中但不在第二个数组中的元素。
array_frequency(array(T)): 返回一个 Map，其中包含了每个元素及其出现的次数。
array_has_duplicates(array(T)): 判断数组中是否有重复元素。
array_intersect(array1(T), array2(T)): 返回两个数组的交集。
array_join(array(T), delimiter, [null_replacement]): 将数组元素连接成字符串。
array_least_frequent(array(T)): 返回数组中出现频率最低的元素。
array_max(array(T)): 返回数组中的最大值。
array_min(array(T)): 返回数组中的最小值。
array_max_by(array(T), function(T,V)), array_min_by(array(T), function(T,V)): 分别返回使函数返回最大值和最小值的数组元素。
array_normalize(array(T)): 返回数组中每个元素的值除以数组元素的总和。
array_position(array(T), element): 返回元素在数组中的位置，如果不存在则返回 0。
array_remove(array(T), element): 返回一个数组，其中移除了所有和给定元素相等的元素。
array_sort(array(T)), array_sort_desc(array(T)): 分别返回按升序和降序排序的数组。
array_sum(array(T)): 返回数组元素的总和。
array_top_n(array(T), n): 返回数组中的前 n 个最大元素。
arrays_overlap(array1(T), array2(T)): 判断两个数组是否有交集。
array_union(array1(T), array2(T)): 返回两个数组的并集。
cardinality(array(T)): 返回数组的长度。
combinations(array(T), n): 返回数组所有可能的 n 元组。
contains(array(T), element): 判断数组是否包含指定元素。
element_at(array(T), index): 返回数组指定位置的元素。
filter(array(T), function(T,boolean)): 返回数组中满足指定条件的元素。
flatten(array(T)): 将多维数组转化为一维数组。
find_first(array(T), element), find_first_index(array(T), element): 分别返回数组中第一个与给定元素相等的元素和其索引。
ngrams(array(T), n): 返回数组所有可能的 n 元组。
none_match(array(T), function(T,boolean)): 判断数组中是否没有元素满足指定的条件。
reduce(array(T), initialState S, inputFunction(S,T,V), outputFunction(S,R)): 将数组元素以指定的方式进行合并。
remove_nulls(array(T)): 返回一个数组，其中移除了所有的 NULL 元素。
repeat(element, count): 返回一个数组，其中包含了 count 个 element。
sequence(start, stop, [step]): 返回一个包含指定序列的数组。
shuffle(array(T)): 返回一个随机排列的数组。
slice(array(T), start, length): 返回数组的一个子数组。
trim_array(array(T)): 返回一个数组，其中移除了开始和结束的 NULL 元素。
transform(array(T), function(T,V)): 返回一个数组，其中的每个元素都是将函数应用在原数组元素上的结果。
zip(array1(T), array2(U), …), zip_with(array(T), array(U), function(T,U,V)): 分别返回一个由数组元素组成的元组的数组，和一个由函数应用在元组上的结果组成的数组。

注意，上述中的 T, U, V, S, R 都表示数据的类型。希望这些信息能帮助你更好地理解和使用 Presto 中的数组函数。

Map Functions and Operators

[] 操作符

在 Presto SQL 中，[] 操作符也可以用于从 map 类型的字段中获取对应键（key）的值。例如：

SELECT name_to_age_map['Bob'] AS bob_age;

在这个查询中，name_to_age_map 是一个 map 类型的字段，它的键是名字（字符串类型），值是年龄（整数类型）。name_to_age_map[‘Bob’] 将返回 map 中键为 ‘Bob’ 的值，也就是 Bob 的年龄。

请注意，如果 map 中不存在给定的键，该操作将返回 NULL。你可以使用 map_contains() 函数来检查 map 是否包含指定的键，避免出现 NULL 结果。

map 函数

在 Presto SQL 中，map 函数用于处理 map 类型数据。以下是你提到的这些函数的简要介绍：

all_keys_match(map(K,V), function(K,boolean)), any_keys_match(map(K,V), function(K,boolean)): 判断 map 中的所有键/任何一个键是否满足指定函数。
any_values_match(map(K,V), function(V,boolean)): 判断 map 中的任何一个值是否满足指定函数。
map(array(K), array(V)): 从两个数组中创建一个 map，其中第一个数组是键，第二个数组是值。
map_from_entries(array(row(K,V))): 从一个包含键-值对的数组中创建一个 map。
multimap_from_entries(array(row(K,V))): 从一个包含键-值对的数组中创建一个多值 map。
map_entries(map(K,V)): 将 map 转换为一个包含键-值对的数组。
map_concat(map1(K,V), map2(K,V), …): 将多个 map 连接在一起。
map_filter(map(K,V), function(K,V,boolean)): 返回一个新的 map，其中只包含满足指定函数的键-值对。
map_remove_null_values(map(K,V)): 返回一个新的 map，其中移除了所有值为 NULL 的键-值对。
map_subset(map1(K,V), map2(K,V)): 判断第一个 map 是否是第二个 map 的子集。
map_key_exists(map(K,V), key): 判断 map 中是否存在指定的键。
map_keys(map(K,V)): 返回一个包含 map 所有键的数组。
map_top_n_keys(map(K,V), n): 返回一个包含 map 中前 n 个键的数组。
map_keys_by_top_n_values(map(K,V), n): 返回一个包含 map 中前 n 个值对应的键的数组。
map_top_n(map(K,V), n): 返回一个新的 map，其中只包含前 n 个键-值对。
map_normalize(map(K,V)): 返回一个新的 map，其中每个值都除以所有值的总和。
map_values(map(K,V)): 返回一个包含 map 所有值的数组。
map_top_n_values(map(K,V), n): 返回一个包含 map 中前 n 个值的数组。
map_zip_with(map(K,V), map(K,W), function(K,V,W,R)): 返回一个新的 map，其中每个值都是将函数应用在原 map 中相同键的值上的结果。
no_keys_match(map(K,V), function(K,boolean)), no_values_match(map(K,V), function(V,boolean)): 判断 map 中的没有键/值满足指定函数。
transform_keys(map(K,V), function(K,V,U)), transform_values(map(K,V), function(K,V,U)): 返回一个新的 map，其中的每个键/值都是将函数应用在原 map 的键/值上的结果。

在这些函数中，K, V, W, R, U 都代表数据的类型。希望这些信息可以帮助你更好地理解和使用 Presto 中的 map 函数。

URL Functions

URL抽取函数

在 Presto SQL 中，提供了一系列的抽取函数(Extraction Functions)，可以用来从 URL 中抽取特定部分。这些函数包括：

url_extract_fragment(url): 这个函数返回给定 URL 中的片段部分。片段是 URL 中 # 后面的部分。例如，url_extract_fragment(‘http://example.com/path#fragment’) 返回 ‘fragment’。
url_extract_host(url): 这个函数返回给定 URL 中的主机名。例如，url_extract_host(‘http://example.com/path’) 返回 ‘example.com’。
url_extract_parameter(url, parameter_name): 这个函数返回给定 URL 查询字符串中指定参数的值。如果参数不存在，则返回 NULL。例如，url_extract_parameter(‘http://example.com/path?name=value’, ‘name’) 返回 ‘value’。
url_extract_path(url): 这个函数返回给定 URL 的路径部分。路径是 URL 中主机名和查询字符串之间的部分。例如，url_extract_path(‘http://example.com/path’) 返回 ‘/path’。
url_extract_port(url): 这个函数返回给定 URL 的端口号。如果 URL 中没有指定端口号，则返回默认的 HTTP 或 HTTPS 端口。例如，url_extract_port(‘http://example.com:8080/path’) 返回 8080。
url_extract_protocol(url): 这个函数返回给定 URL 的协议部分。例如，url_extract_protocol(‘http://example.com/path’) 返回 ‘http’。
url_extract_query(url): 这个函数返回给定 URL 的查询字符串部分。查询字符串是 URL 中 ? 后面的部分。例如，url_extract_query(‘http://example.com/path?name=value’) 返回 ‘name=value’。

这些函数使得在 SQL 查询中处理和分析 URL 数据变得简单方便。

URL编码函数

在 Presto SQL 中，编码函数(Encoding Functions)是用来对字符串进行编码或解码的。以下是你所提到的这两个函数的简要介绍：

url_encode(string): 这个函数返回 URL 编码后的字符串。URL 编码也被称为百分号编码，它是一种将非字母数字字符编码为 %XY 格式的机制，其中 XY 是字符在 ASCII 表中的十六进制代码。这在构建有效的 URL 时非常有用，特别是对于查询参数的编码。例如，url_encode(‘hello world!’) 返回 ‘hello%20world%21’。
url_decode(string): 这个函数返回 URL 解码后的字符串。它执行的操作与 url_encode 函数相反，将 %XY 格式的编码转换回原始字符。例如，url_decode(‘hello%20world%21’) 返回 ‘hello world!’。

注意，url_encode 和 url_decode 是互逆的操作，也就是说对一个字符串先进行 URL 编码，然后再进行 URL 解码，得到的结果应该是原始字符串。同样的，对一个字符串先进行 URL 解码，然后再进行 URL 编码，如果原始字符串已经是正确的 URL 编码，那么得到的结果应该是原始字符串。

IP Functions

在 Presto SQL中，IP函数（IP Functions）可以用来处理IP地址和子网。以下是你所提到的这些函数的简要介绍：

ip_prefix(ip_address, subnet_size): 这个函数接收一个IP地址和一个子网大小，然后返回该子网的CIDR表示。例如，ip_prefix(‘192.0.2.0’, 24) 返回 ‘192.0.2.0/24’。
ip_subnet_min(subnet_address): 这个函数接收一个子网地址，然后返回该子网中的最小IP地址。例如，ip_subnet_min(‘192.0.2.0/24’) 返回 ‘192.0.2.0’。
ip_subnet_max(subnet_address): 这个函数接收一个子网地址，然后返回该子网中的最大IP地址。例如，ip_subnet_max(‘192.0.2.0/24’) 返回 ‘192.0.2.255’。
ip_subnet_range(subnet_address): 这个函数接收一个子网地址，然后返回一个表示该子网中所有IP地址的数组。例如，ip_subnet_range(‘192.0.2.0/30’) 返回 [‘192.0.2.0’, ‘192.0.2.1’, ‘192.0.2.2’, ‘192.0.2.3’]。
is_subnet_of(ip_address, subnet_address): 这个函数接收一个IP地址和一个子网地址，如果IP地址位于子网中，则返回 true，否则返回 false。例如，is_subnet_of(‘192.0.2.3’, ‘192.0.2.0/24’) 返回 true，而 is_subnet_of(‘192.0.3.3’, ‘192.0.2.0/24’) 返回 false。

这些函数可以帮助你在SQL查询中处理和分析IP地址和子网。

Geospatial Functions

构造函数

在 Presto SQL 中，构造函数(Constructors)用来创建新的几何对象。以下是您所提到的这些函数的简要介绍：

ST_AsBinary(geometry): 这个函数返回给定几何对象的 Well-Known Binary (WKB) 表示。
ST_AsText(geometry): 这个函数返回给定几何对象的 Well-Known Text (WKT) 表示。
ST_GeometryFromText(wkt): 这个函数根据输入的 Well-Known Text (WKT) 创建一个新的几何对象。
ST_GeomFromBinary(wkb): 这个函数根据输入的 Well-Known Binary (WKB) 创建一个新的几何对象。
ST_LineFromText(wkt): 这个函数根据输入的 Well-Known Text (WKT) 创建一个新的线对象。
ST_LineString(point1, point2, …): 这个函数根据输入的点创建一个新的线对象。
ST_MultiPoint(point1, point2, …): 这个函数根据输入的点创建一个新的多点对象。
ST_Point(x, y): 这个函数创建一个新的点对象。
ST_Polygon(lineString): 这个函数根据输入的线字符串创建一个新的多边形对象。
to_spherical_geography(geometry): 这个函数将输入的几何对象转换为球面地理几何对象。
to_geometry(spherical_geography): 这个函数将输入的球面地理几何对象转换为几何对象。

这些函数对于处理和分析地理和地理空间数据非常有用。

关系测试函数

在 Presto SQL 中，关系测试函数(Relationship Tests)用于确定两个几何对象之间的空间关系。以下是你提到的这些函数的简要介绍：

ST_Contains(geometry1, geometry2): 如果几何对象1包含几何对象2，则返回 true。
ST_Crosses(geometry1, geometry2): 如果几何对象1和几何对象2交叉，则返回 true。
ST_Disjoint(geometry1, geometry2): 如果几何对象1和几何对象2在空间上是不相交的，则返回 true。
ST_Equals(geometry1, geometry2): 如果几何对象1在空间上等于几何对象2，则返回 true。
ST_Intersects(geometry1, geometry2): 如果几何对象1和几何对象2在空间上相交，则返回 true。
ST_Overlaps(geometry1, geometry2): 如果几何对象1和几何对象2在空间上重叠，则返回 true。
ST_Relate(geometry1, geometry2, pattern): 根据给定的9交矩阵模式字符串，判断几何对象1和几何对象2的空间关系。
ST_Touches(geometry1, geometry2): 如果几何对象1和几何对象2在空间上接触，即它们至少有一个公共点，但他们的内部并不相交，则返回 true。
ST_Within(geometry1, geometry2): 如果几何对象1在几何对象2内，则返回 true。

这些函数对于处理和分析地理和地理空间数据非常有用，特别是在确定几何对象之间的空间关系时。

操作函数

在 Presto SQL 中，操作函数(Operations)用于对几何对象进行一些空间操作。以下是你提到的这些函数的简要介绍：

geometry_union(array(geometry)): 这个函数返回一个数组中所有几何对象的并集。
ST_Boundary(geometry): 这个函数返回一个几何对象的边界。
ST_Buffer(geometry, distance): 这个函数返回一个几何对象的缓冲区，即包含与原始几何对象的所有点的距离不超过指定距离的所有点的几何对象。
ST_Difference(geometry1, geometry2): 这个函数返回几何对象1和几何对象2的差集，即只存在于几何对象1中的部分。
ST_Envelope(geometry): 这个函数返回一个几何对象的最小边界矩形。
ST_EnvelopeAsPts(geometry): 这个函数返回一个表示几何对象最小边界矩形的点数组。
expand_envelope(envelope, point): 这个函数扩展一个最小边界矩形以包含一个额外的点。
ST_ExteriorRing(polygon): 这个函数返回一个多边形的外环。
ST_Intersection(geometry1, geometry2): 这个函数返回几何对象1和几何对象2的交集。
ST_SymDifference(geometry1, geometry2): 这个函数返回几何对象1和几何对象2的对称差集，即只存在于一个几何对象中但不是两者共有的部分。
ST_Union(geometry1, geometry2): 这个函数返回几何对象1和几何对象2的并集。

这些函数对于处理和分析地理和地理空间数据非常有用，特别是在执行几何对象之间的空间操作时。

访问函数

在 Presto SQL 中，访问函数(Accessors)用于获取几何对象的属性或执行对其的某些计算。以下是你提到的这些函数的简要介绍：

ST_Area(geometry): 计算几何对象的面积。
ST_Centroid(geometry): 计算几何对象的质心。
ST_ConvexHull(geometry): 计算几何对象的凸包。
ST_CoordDim(geometry): 返回几何对象的坐标维数。
ST_Dimension(geometry): 返回几何对象的维度。
ST_Distance(geometry1, geometry2): 计算两个几何对象之间的最短距离。
geometry_nearest_points(geometry1, geometry2): 返回两个几何对象之间最近点的对。
ST_GeometryN(geometry, n): 返回几何集合中第n个几何对象。
ST_InteriorRingN(geometry, n): 返回多边形的第n个内环。
ST_GeometryType(geometry): 返回几何对象的类型。
ST_IsClosed(geometry): 如果几何对象是封闭的，返回 true。
ST_IsEmpty(geometry): 如果几何对象是空的，返回 true。
ST_IsSimple(geometry): 如果几何对象是简单的，返回 true。
ST_IsRing(geometry): 如果线对象是环，返回 true。
ST_IsValid(geometry): 如果几何对象是有效的，返回 true。
ST_Length(geometry): 计算线或多线的长度。
ST_PointN(geometry, n): 返回线上的第n个点。
ST_Points(geometry): 返回线或多线的所有点。
ST_XMax(geometry), ST_YMax(geometry), ST_XMin(geometry), ST_YMin(geometry): 返回几何对象的最大或最小X或Y坐标。
ST_StartPoint(geometry), ST_EndPoint(geometry): 返回线或多线的起点或终点。
ST_X(geometry), ST_Y(geometry): 返回点的X或Y坐标。
ST_InteriorRings(geometry): 返回多边形的所有内环。
ST_NumGeometries(geometry): 返回几何集合中的几何对象数量。
ST_Geometries(geometry): 返回几何集合中的所有几何对象。
flatten_geometry_collections(geometry): 返回几何集合的所有几何对象，但不包括几何集合。
ST_NumPoints(geometry): 返回线或多线的点数。
ST_NumInteriorRing(geometry): 返回多边形的内环数量。
simplify_geometry(geometry, tolerance): 返回一个简化的几何对象，以给定的公差为界。
line_locate_point(line, point): 返回线上最接近给定点的点的比例距离。
line_interpolate_point(line, fraction): 返回线上给定比例距离的点。
geometry_invalid_reason(geometry): 如果几何对象无效，返回原因。
great_circle_distance(point1, point2): 返回两点间的大圆距离。
geometry_as_geojson(geometry), geometry_from_geojson(json): 返回几何对象的GeoJSON表示，或从GeoJSON创建几何对象。

这些函数有助于处理和分析地理和地理空间数据，特别是在获取几何对象的属性或执行计算时。

聚合函数

在 Presto SQL 中，聚合函数(Aggregations)用于对几何对象的集合进行一些计算和操作：

convex_hull_agg(geometry): 这个函数对输入的几何对象集合进行聚合，并返回这些对象的凸包。凸包是包含输入集合中所有点，并且所有内角都小于180度的最小凸多边形。例如，SELECT convex_hull_agg(geometry) FROM table 返回表中所有几何对象的凸包。
geometry_union_agg(geometry): 这个函数对输入的几何对象集合进行聚合，并返回这些对象的并集。结果几何对象包含输入集合中所有几何对象的所有点。例如，SELECT geometry_union_agg(geometry) FROM table 返回表中所有几何对象的并集。

这些函数在处理和分析地理和地理空间数据时非常有用，特别是在需要对大量几何对象进行操作时。

Bing Tiles 函数

在 Presto SQL 中，Bing Tiles 函数用于处理 Bing Maps 的切片系统相关的操作。以下是你提到的这些函数的简要介绍：

bing_tile(quad_key), bing_tile(x, y, zoom_level): 这两个函数返回一个 Bing Tile，通过四键值或 x、y 坐标和缩放级别指定。
bing_tile_parent(tile): 这个函数返回给定 Bing Tile 的父 Tile。
bing_tile_children(tile): 这个函数返回给定 Bing Tile 的所有子 Tile。
bing_tile_at(latitude, longitude, zoom_level): 这个函数返回包含给定纬度和经度的 Bing Tile。
bing_tiles_around(latitude, longitude, radius, zoom_level): 这个函数返回包含给定纬度和经度周围的所有 Bing Tile。
bing_tile_coordinates(tile): 这个函数返回一个给定 Bing Tile 的x, y坐标。
bing_tile_polygon(tile): 这个函数返回一个表示给定 Bing Tile 的多边形。
bing_tile_quadkey(tile): 这个函数返回一个给定 Bing Tile 的四键值。
bing_tile_zoom_level(tile): 这个函数返回一个给定 Bing Tile 的缩放级别。
geometry_to_bing_tiles(geometry, zoom_level): 这个函数返回一个数组，包含与给定几何对象相交的所有 Bing Tiles。
geometry_to_dissolved_bing_tiles(geometry, zoom_level, max_tiles): 这个函数返回一个几何对象，它表示所有与给定几何对象相交的 Bing Tiles 的并集。

这些函数可以帮助处理与 Bing Maps 切片系统相关的操作，包括创建 Bing Tiles、查询 Bing Tiles 的属性和与 Bing Tiles 相关的地理空间计算。

HyperLogLog Functions

Presto提供了一套HyperLogLog函数，用于对大数据集进行基数估计。HyperLogLog是一种概率数据结构，用于估计数据集的不同元素数量，也就是基数。它相较于精确计数，可以显著降低存储和计算的开销。以下是Presto中的一些HyperLogLog函数：

在 Presto SQL 中，以下是你提到的这些函数的简要介绍：

approx_set(value): 这个函数在一个 HyperLogLog 数据结构中添加一个元素，该结构用于基数估计。可以使用此函数来创建一个唯一值的近似集合，消耗的内存将远远低于精确的唯一计数。
empty_approx_set(): 这个函数返回一个空的 HyperLogLog 数据结构，可以用于基数估计。
merge(HyperLogLog): 这个函数合并多个 HyperLogLog 数据结构，结果是一个新的 HyperLogLog，包含所有输入 HyperLogLog 的所有元素。此函数可用于合并通过 approx_set 函数创建的多个集合。
merge_hll(HyperLogLog): 这个函数与 merge 函数相同，都是用来合并多个 HyperLogLog 数据结构。在早期的 Presto 版本中，merge 函数被命名为 merge_hll，现在已经被 merge 函数取代。

这些函数提供了一种进行基数估计的方法，这对于大规模数据集的处理非常有用，尤其是当需要进行唯一值计数，但内存有限时。

KHyperLogLog Functions

Presto 的 KHyperLogLog 函数是用于处理 KHyperLogLog 数据结构的。KHyperLogLog 是一种概率数据结构，用于估计数据集中不同元素的数量，即基数。与 HyperLogLog 类似，KHyperLogLog 提供了对存储和计算需求的优化，但它还提供了对集合运算的支持，例如交集和差集。

以下是 Presto 中的一些 KHyperLogLog 函数：

khyperloglog_agg(x): 这个函数聚合一组值，并返回一个 KHyperLogLog 实例，该实例包含所有的输入值。
intersection_cardinality(KHyperLogLog1, KHyperLogLog2): 这个函数用于估计两个 KHyperLogLog 实例的交集的基数。
jaccard_index(KHyperLogLog1, KHyperLogLog2): 这个函数返回两个 KHyperLogLog 实例的 Jaccard 索引，即他们的交集大小与并集大小之比。
uniqueness_distribution(KHyperLogLog): 这个函数返回一个 KHyperLogLog 实例的唯一性分布，即每个基数的频率。
reidentification_potential(KHyperLogLog): 这个函数返回一个 KHyperLogLog 实例的重识别潜力，即任何给定元素被误识别为另一个元素的可能性。
merge_khll(KHyperLogLog): 这个函数合并多个 KHyperLogLog 实例，并返回一个新的 KHyperLogLog 实例，该实例包含所有输入实例的元素。

这些函数可以用来进行大规模数据集的基数估计，并支持集合运算，这对于处理大数据特别有用。

Quantile Digest Functions

Presto 的 Quantile Digest 函数是用于处理 Quantile Digest 数据结构的。Quantile Digest 是一种概率数据结构，用于估算数据流中的百分位数和频率。与精确计算相比，Quantile Digest 消耗的存储和计算开销要小得多。

以下是 Presto 中的一些 Quantile Digest 函数：

value_at_quantile(qdigest(T), quantile): 这个函数返回指定q-digest在给定百分位数处的值。这对于寻找数据集中特定百分位数的值非常有用。
quantile_at_value(qdigest(T), value): 这个函数返回指定q-digest中给定值所对应的百分位数。这可以帮助你理解给定值在整个数据集中的相对位置。
scale_qdigest(qdigest(T), scale_factor): 这个函数调整q-digest的规模，该规模决定了q-digest的精度和大小。增加规模因子将增加精度和大小，减少规模因子将减少精度和大小。
values_at_quantiles(qdigest(T), array(quantile)): 这个函数返回指定q-digest在给定多个百分位数处的值。这对于同时寻找数据集中多个百分位数的值非常有用。
qdigest_agg(x): 这个函数对一组值进行聚合，生成一个q-digest实例。这是创建q-digest的主要方法，可以用于大规模数据集的百分位数和频率估计。

这些函数提供了一种处理大规模数据集的百分位数和频率估算的方法，特别适合内存有限的情况。

UUID functions

Presto中的UUID函数是一组处理UUID（Universally Unique Identifier，通用唯一识别码）的函数。这些函数提供了生成、比较和解析UUID的功能。

uuid(): 这个函数生成一个随机的UUID。

T-Digest Functions

Presto的T-Digest函数是一组处理T-Digest（T-分位数摘要）数据结构的函数。T-Digest是一种概率型数据结构，用于估计数据流中的百分位数，特别适合处理大规模和动态数据。

以下是Presto中的一些T-Digest函数：

value_at_quantile(tdigest(double), double): 这个函数返回指定的T-Digest在给定百分位数处的值。这种函数可以用于找到数据集中特定百分位的值。
quantile_at_value(tdigest(double), double): 这个函数返回T-Digest中给定值对应的百分位数。这可以帮助你理解给定值在整个数据集中的相对位置。
scale_tdigest(tdigest(double), double): 这个函数返回一个新的T-Digest，它的规模因子为原始T-Digest的规模因子与给定值的乘积。规模因子越大，T-Digest的精度越高，但所需的存储空间也越大。
values_at_quantiles(tdigest(double), array(double)): 这个函数返回指定的T-Digest在给定多个百分位数处的值。你可以用这个函数找到数据集中多个百分位的值。
trimmed_mean(tdigest(double), min_quantile, max_quantile): 这个函数返回指定的T-Digest在给定的最小和最大百分位数之间的所有值的平均值。
tdigest_agg(double): 这个函数对一组值进行聚合，生成一个T-Digest实例。它是创建T-Digest的主要方法，可以用于大规模数据集的百分位数和频率估计。
destructure_tdigest(tdigest(double)): 这个函数将T-Digest分解为一个由结构元组组成的数组，每个元组包含一个centroid的mean和weight。这可以让你检查T-Digest的内部结构。
construct_tdigest(array(row(double, double))): 这个函数接受一个数组，每个元素是一个包含mean和weight的行，返回一个由这些centroid构成的T-Digest。
merge_tdigest(tdigest(double)): 这个函数合并多个T-Digest实例，并返回一个新的T-Digest实例，包含所有输入T-Digest的所有元素。

这些函数提供了一种强大的工具，可以用于处理大规模数据集的百分位数估计，特别适合内存有限的情况。

Color Functions

Presto的Color函数是一组处理颜色和颜色代码的函数。这些函数提供了颜色的解析、转换和处理功能。

以下是Presto中的一些Color函数：

bar(double, double, varchar, varchar, varchar): 这个函数生成一个简单的柱状图，其中的每一项都由特定的字符表示。第一个参数是值，第二个参数是最大值，第三个参数是全角字符，第四个参数是半角字符，第五个参数是空白字符。例如，bar(5, 10, ‘=’, ‘-‘, ‘ ‘) 将生成一个长度为10的柱状图，其中前半部分是由等号表示，后半部分是由空格表示。
color(string): 这个函数将颜色名称或颜色代码转换为十六进制数。支持的颜色名称包括基本的16种HTML颜色名称，如”black”、”white”、”red”等，也支持RGB颜色代码，如”#RRGGBB”或”#RGB”。
render(varchar, map(varchar, varchar)): 这个函数使用一个模板和一个变量映射来渲染一个字符串。模板中的变量用${variable}的形式表示，映射中的键是变量名，值是要替换变量的字符串。
rgb(int, int, int): 这个函数根据提供的红、绿、蓝三种颜色的值生成一个颜色。颜色值的范围在0到255之间。返回的颜色是一个6位的十六进制数，代表颜色的RGB代码。

这些函数使得在处理涉及颜色的数据时更加方便，包括解析颜色代码、生成颜色和生成简单的柱状图。

Session Information

Presto的会话信息(Session Information)是指在一个Presto查询会话中的一系列参数和配置。这些信息主要用于在Presto查询时确定运行环境和行为。

Teradata Functions

Presto的Teradata函数是一组函数，它们模拟Teradata数据库中相同名称的函数的行为。这些函数主要用于处理字符串、日期和时间，以及数值计算。

以下是一些常见的Presto Teradata函数：

字符串函数(String Functions):

char2hexint(string): 这个函数返回一个十六进制表示的字符串，对应于输入字符串中的每个字符的Unicode代码点。
index(string, substring): 这个函数返回substring在string中的起始位置。如果没有找到substring，那么返回值为0。
substring(string, start, length): 这个函数返回string的一个子串，从start位置开始，长度为length。如果只给出start参数而没有给出length参数，那么子串将包含从start位置开始到string末尾的所有字符。

日期函数(Date Functions):

to_char(value, format): 这个函数返回一个字符串，表示value的值，使用给定的格式。value可以是日期、时间或时间戳，格式是一个表示日期和时间格式的字符串。
to_timestamp(string, format): 这个函数根据给定的格式将一个字符串解析为一个时间戳。
to_date(string, format): 这个函数根据给定的格式将一个字符串解析为一个日期。

以上只是一部分Teradata函数，你可以在Presto的官方文档中查看所有的Teradata函数。这些函数为在Presto中处理数据提供了更多的灵活性和方便性，特别是对于熟悉Teradata数据库系统的用户。

Internationalization Functions

在Presto中，Myanmar函数是一系列专门用于处理缅甸语文字的函数。以下是你提到的这些函数的介绍：

myanmar_font_encoding(string): 这个函数返回一个表示输入字符串所使用的字体编码的字符串。可能的返回值包括’zawgyi’、’unicode’或’unknown’。
myanmar_normalize_unicode(string): 这个函数将输入字符串中的缅甸语字符标准化为Unicode表示形式。如果输入字符串已经是Unicode，那么返回值与输入相同。

这些函数对于处理缅甸语文本非常有用，特别是在涉及到字体编码和字符标准化的情况下。

Set Digest functions

在Presto中，Set Digest函数是用于创建和操作set digest数据类型的一组函数。Set Digest数据类型是一种特殊的数据结构，用于存储一组唯一的元素，并支持高效的集合操作。

以下是一些常见的Set Digest函数：

make_set_digest(value): 这个函数用于创建一个新的set digest，其中包含给定的值。
merge_set_digest(setDigest1, setDigest2): 这个函数用于合并两个set digest，结果是一个包含两个输入set digest所有元素的新set digest。
cardinality(setDigest): 这个函数返回给定set digest中元素的数量。
intersection_cardinality(setDigest1, setDigest2): 这个函数返回两个set digest的交集的大小。
jaccard_index(setDigest1, setDigest2): 这个函数返回两个set digest的Jaccard指数，这是一个衡量两个集合相似度的指标，范围是0到1。
hash_counts(setDigest): 这个函数返回一个map，其中的键是set digest中的元素，值是各元素在set digest中出现的次数。

使用Set Digest函数，你可以有效地处理大规模的集合数据，并进行如并集、交集等集合操作。这对于处理涉及大量唯一元素的数据分析非常有用。

Sketch Functions

在Presto中，Theta Sketches和KLL Sketches是两种用于数据流分析的模型。Theta Sketches主要用于估算不重复元素的数量，KLL Sketches用于分位数和排名的估算。

以下是你提到的这些函数的介绍：

Theta Sketches

sketch_theta(): 创建一个空的Theta sketch。
sketch_theta_estimate(sketch): 返回Theta sketch的估计元素数量。
sketch_theta_summary(sketch): 返回Theta sketch的一些统计摘要信息，例如存储的元素数量、存储容量等。

KLL Sketches

sketch_kll(): 创建一个空的KLL sketch。
sketch_kll_with_k(k): 创建一个带有指定参数k的KLL sketch。参数k决定了KLL sketch的准确性和内存使用情况。
sketch_kll_quantile(sketch, probability): 返回KLL sketch在指定概率下的分位数。
sketch_kll_rank(sketch, value): 返回指定值在KLL sketch中的排名，结果是一个介于0和1之间的浮点数。

这些函数在处理大规模数据分析时非常有用，Theta Sketches可以用于估计大数据集中的唯一元素数量，KLL Sketches可以用于估算大数据集的分位数和排名。

参考链接：Presto Documentation — Presto 0.287 Documentation (prestodb.io)