Amazon Redshift SQL 转换指南

本文档详细介绍了 Amazon Redshift 和 BigQuery 在 SQL 语法方面的异同，以帮助您规划迁移。使用批量 SQL 转换来批量迁移 SQL 脚本，或使用交互式 SQL 转换来转换临时查询。

本指南的目标受众是企业架构师、数据库管理员、应用开发者和 IT 安全专家。此外，还假设您熟悉 Amazon Redshift。

数据类型

本部分介绍了 Amazon Redshift 和 BigQuery 中的数据类型之间的等效项。

Amazon Redshift BigQuery 备注
数据类型 别名 数据类型
SMALLINT INT2 INT64 Amazon Redshift 的 SMALLINT 为 2 个字节，而 BigQuery 的 INT64 为 8 个字节。
INTEGER

INT, INT4

 INT64 Amazon Redshift 的 INTEGER 为 4 个字节，而 BigQuery 的 INT64 为 8 个字节。
BIGINT INT8 INT64 Amazon Redshift 的 BIGINT 和 BigQuery 的 INT64 均为 8 个字节。
DECIMAL NUMERIC NUMERIC
REAL FLOAT4 FLOAT64 Amazon Redshift 的 REAL 为 4 个字节，而 BigQuery 的 FLOAT64 为 8 个字节。
DOUBLE PRECISION

FLOAT8, FLOAT

 FLOAT64
BOOLEAN BOOL BOOL Amazon Redshift 的 BOOLEAN 可以使用 TRUE、t、true、y、yes 和 1 作为 true 的有效字面量值。BigQuery 的 BOOL 数据类型使用不区分大小写的 TRUE。
CHAR

CHARACTER, NCHAR, BPCHAR

STRING
VARCHAR

CHARACTER VARYING, NVARCHAR, TEXT

STRING
DATE DATE
TIMESTAMP TIMESTAMP WITHOUT TIME ZONE DATETIME
TIMESTAMPTZ

TIMESTAMP WITH TIME ZONE

TIMESTAMP 注意：在 BigQuery 中，当解析时间戳或设置时间戳格式以用于显示时，系统会使用时区。字符串格式的时间戳可能包含时区，但当 BigQuery 解析字符串时，会采用等效的世界协调时间 (UTC) 存储该时间戳。如果未明确指定时区，则系统会使用默认时区，即世界协调时间 (UTC)。支持时区名称或使用 (-|+)HH:MM 表示相对于世界协调时间 (UTC) 的偏移量，但不支持时区缩写（如 PDT）。
GEOMETRY GEOGRAPHY 支持查询地理空间数据。

BigQuery 还具有以下数据类型，这些数据类型没有直接的 Amazon Redshift 模拟：

隐式转换类型

迁移到 BigQuery 时，您需要将大多数 Amazon Redshift 隐式转换转换为 BigQuery 的显式转换，但 BigQuery 隐式转换的以下数据类型除外。

BigQuery 会对以下数据类型执行隐式转换：

从 BigQuery 类型 到 BigQuery 类型

INT64

FLOAT64

INT64

NUMERIC

NUMERIC

FLOAT64

BigQuery 还会对以下字面量执行隐式转换：

从 BigQuery 类型 到 BigQuery 类型
STRING 字面量
（例如“2008-12-25”）

DATE

STRING 字面量
（例如“2008-12-25 15:30:00”）

TIMESTAMP

STRING 字面量
（例如“2008-12-25T07:30:00”）

DATETIME

STRING 字面量
（例如“15:30:00”）

TIME

显式转换类型

您可以使用 BigQuery 的 CAST(expression AS type) 函数或任何 DATE 和 TIMESTAMP 转换函数来转换 BigQuery 不会隐式转换的 Amazon Redshift 数据类型。

迁移查询时，请将 Amazon Redshift CONVERT(type, expression) 函数（或 :: 语法）的任何发生实例更改为 BigQuery 的 CAST(expression AS type) 函数，如 数据类型格式设置函数部分中的表所示。

查询语法

本部分介绍了 Amazon Redshift 和 BigQuery 在查询语法方面的差异。

SELECT 语句

大多数 Amazon Redshift SELECT 语句都与 BigQuery 兼容。下表列出了一些细微差异。

Amazon Redshift BigQuery

SELECT TOP number expression
FROM table

SELECT expression
FROM table
ORDER BY expression DESC
LIMIT number

SELECT
x/total AS probability,
ROUND(100 * probability, 1) AS pct
FROM raw_data

注意：Redshift 支持在同一 SELECT 语句中创建和引用别名。

SELECT
x/total AS probability,
ROUND(100 * (x/total), 1) AS pct
FROM raw_data

BigQuery 还支持 SELECT 语句中的以下表达式，这些表达式没有 Amazon Redshift 等效项：

FROM 子句

查询中的 FROM 子句会列出要从中选择数据的表引用。在 Amazon Redshift 中，可能的表引用包括表、视图和子查询。BigQuery 支持所有这些表引用。

您可以使用以下语句在 FROM 子句中引用 BigQuery 表：

  • [project_id].[dataset_id].[table_name]
  • [dataset_id].[table_name]
  • [table_name]

BigQuery 还支持其他表引用：

JOIN 类型

Amazon Redshift 和 BigQuery 都支持以下联接类型：

  • [INNER] JOIN
  • LEFT [OUTER] JOIN
  • RIGHT [OUTER] JOIN
  • FULL [OUTER] JOIN
  • CROSS JOIN 和等效的隐式逗号交叉联接。

下表列出了一些细微差异。

Amazon Redshift BigQuery

SELECT col
FROM table1
NATURAL INNER JOIN
table2

SELECT col1
FROM table1
INNER JOIN
table2
USING (col1, col2 [, ...])


注意：在 BigQuery 中，除非子句是 CROSS JOIN 或其中一个联接表是数据类型或数组中的某个字段，否则 JOIN 子句需要 JOIN 条件。

WITH 子句

BigQuery WITH 子句包含一个或多个已命名的子查询，当后续 SELECT 语句引用这些子查询时，将执行这些子查询。Amazon Redshift WITH 子句的行为与 BigQuery 相同，不同之处在于您可以计算一次子句并重复使用其结果。

集合运算符

Amazon Redshift 集合运算符与 BigQuery 集合运算符之间存在一些细微差异。但是，Amazon Redshift 中可进行的所有集合运算都在 BigQuery 中可复制。

Amazon Redshift BigQuery

SELECT * FROM table1
UNION
SELECT * FROM table2

SELECT * FROM table1
UNION DISTINCT
SELECT * FROM table2

注意：BigQuery 和 Amazon Redshift 都支持 UNION ALL 运算符。

SELECT * FROM table1
INTERSECT
SELECT * FROM table2

SELECT * FROM table1
INTERSECT DISTINCT
SELECT * FROM table2

SELECT * FROM table1
EXCEPT
SELECT * FROM table2

SELECT * FROM table1
EXCEPT DISTINCT
SELECT * FROM table2

SELECT * FROM table1
MINUS
SELECT * FROM table2

SELECT * FROM table1
EXCEPT DISTINCT
SELECT * FROM table2

SELECT * FROM table1
UNION
SELECT * FROM table2
EXCEPT
SELECT * FROM table3

SELECT * FROM table1
UNION ALL
(
SELECT * FROM table2
EXCEPT
SELECT * FROM table3
)


注意：BigQuery 需要使用英文括号来分隔不同的集合运算。如果重复同一集合运算符，则不需要使用英文括号。

ORDER BY 子句

Amazon Redshift ORDER BY 子句与 BigQuery ORDER BY 子句之间存在一些细微差异。

Amazon Redshift BigQuery
在 Amazon Redshift 中，NULL 默认排在最后（升序）。 在 BigQuery 中，NULL 默认排在最前（升序）。

SELECT *
FROM table
ORDER BY expression
LIMIT ALL

SELECT *
FROM table
ORDER BY expression



注意：BigQuery 不使用 LIMIT ALL 语法，但默认情况下 ORDER BY 会对所有行进行排序，从而导致行为与 Amazon Redshift 的 LIMIT ALL 子句相同。我们强烈建议您在每个 ORDER BY 子句中添加 LIMIT 字句。对所有结果行进行排序会降低查询执行性能，但这并非必要。

SELECT *
FROM table
ORDER BY expression
OFFSET 10

SELECT *
FROM table
ORDER BY expression
LIMIT count OFFSET 10



注意：在 BigQuery 中，OFFSET 必须与 LIMIT count 结合使用。请务必将 count INT64 值设置为所需的已排序行数的下限。对所有结果行进行排序
会不必要地降低查询执行性能。

条件

下表展示了 Amazon Redshift 条件或谓词，它们是 Amazon Redshift 所特有的，必须转换为其 BigQuery 等效项。

Amazon Redshift BigQuery

a = ANY (subquery)

a = SOME (subquery)

a IN subquery

a <> ALL (subquery)

a != ALL (subquery)

a NOT IN subquery

a IS UNKNOWN

expression ILIKE pattern

a IS NULL

LOWER(expression) LIKE LOWER(pattern)

expression LIKE pattern ESCAPE 'escape_char'

expression LIKE pattern


注意：BigQuery 不支持自定义转义字符。您必须将两个反斜杠 \\ 用作 BigQuery 的转义字符。

expression [NOT] SIMILAR TO pattern

IF(
LENGTH(
REGEXP_REPLACE(
expression,
pattern,
''
) = 0,
True,
False
)


注意：如果指定了 NOT，请将上述 IF 表达式封装在 NOT 表达式中，如下所示：

NOT(
IF(
LENGTH(...
)

expression [!] ~ pattern

[NOT] REGEXP_CONTAINS(
expression,
regex
)

函数

以下部分列出了 Amazon Redshift 函数及其 BigQuery 等效项。

聚合函数

下表展示了常见的 Amazon Redshift 聚合、聚合分析和近似聚合函数与其 BigQuery 等效项之间的映射。

Amazon Redshift BigQuery
APPROXIMATE COUNT(DISTINCT expression) APPROX_COUNT_DISTINCT(expression)
APPROXIMATE PERCENTILE_DISC(
percentile
) WITHIN GROUP (ORDER BY expression)		 APPROX_QUANTILES(expression, 100)
[OFFSET(CAST(TRUNC(percentile * 100) as INT64))]
AVG([DISTINCT] expression) AVG([DISTINCT] expression)
COUNT(expression) COUNT(expression)
LISTAGG(
[DISTINCT] aggregate_expression
[, delimiter] )
[WITHIN GROUP (ORDER BY order_list)] 		STRING_AGG(
[DISTINCT] aggregate_expression
[, delimiter]
[ORDER BY order_list] )
MAX(expression) MAX(expression)
MEDIAN(median_expression) PERCENTILE_CONT( median_expression, 0.5 ) OVER()
MIN(expression) MIN(expression)
PERCENTILE_CONT(
percentile
) WITHIN GROUP (ORDER BY expression)		 PERCENTILE_CONT(
median_expression,
percentile
) OVER()

注意：不包含聚合用例。
STDDEV([DISTINCT] expression) STDDEV([DISTINCT] expression)
STDDEV_SAMP([DISTINCT] expression) STDDEV_SAMP([DISTINCT] expression)
STDDEV_POP([DISTINCT] expression) STDDEV_POP([DISTINCT] expression)
SUM([DISTINCT] expression) SUM([DISTINCT] expression)
VARIANCE([DISTINCT] expression) VARIANCE([DISTINCT] expression)
VAR_SAMP([DISTINCT] expression) VAR_SAMP([DISTINCT] expression)
VAR_POP([DISTINCT] expression) VAR_POP([DISTINCT] expression)

BigQuery 还提供以下聚合、聚合分析和近似聚合函数，这些函数在 Amazon Redshift 中没有直接模拟：

按位聚合函数

下表展示了常见的 Amazon Redshift 按位聚合函数与其 BigQuery 等效项之间的映射。

Amazon Redshift BigQuery
BIT_AND(expression) BIT_AND(expression)
BIT_OR(expression) BIT_OR(expression)
BOOL_AND>(expression) LOGICAL_AND(expression)
BOOL_OR(expression) LOGICAL_OR(expression)

BigQuery 还提供以下按位聚合函数，该函数在 Amazon Redshift 中没有直接模拟：

窗口函数

下表展示了常见的 Amazon Redshift 窗口函数与其 BigQuery 等效项之间的映射。BigQuery 中的窗口函数包括分析聚合函数、聚合函数、导航函数和编号函数。


Amazon Redshift BigQuery
AVG(expression) OVER
(
[PARTITION BY expr_list]
[ORDER BY order_list frame_clause]
)		 AVG(expression) OVER
(
[PARTITION BY expr_list]
[ORDER BY order_list]
[frame_clause]
)
COUNT(expression) OVER
(
[PARTITION BY expr_list]
[ORDER BY order_list
frame_clause]
)		 COUNT(expression) OVER
(
[PARTITION BY expr_list]
[ORDER BY order_list]
[frame_clause]
)
CUME_DIST() OVER
(
[PARTITION BY partition_expression]
[ORDER BY order_list]
) 		CUME_DIST() OVER
(
[PARTITION BY partition_expression]
ORDER BY order_list
)
DENSE_RANK() OVER
(
[PARTITION BY expr_list]
[ORDER BY order_list]
) 		DENSE_RANK() OVER
(
[PARTITION BY expr_list]
ORDER BY order_list
)
FIRST_VALUE(expression) OVER
(
[PARTITION BY expr_list]
[ORDER BY order_list
frame_clause]
)		 FIRST_VALUE(expression) OVER
(
[PARTITION BY expr_list]
[ORDER BY order_list]
[frame_clause]
)
LAST_VALUE(expression) OVER
(
[PARTITION BY expr_list]
[ORDER BY order_list
frame_clause]
)		 LAST_VALUE(expression) OVER
(
[PARTITION BY expr_list]
[ORDER BY order_list
frame_clause]
)
LAG(value_expr [, offset]) OVER
(
[PARTITION BY window_partition]
ORDER BY window_ordering
) 		LAG(value_expr [, offset]) OVER
(
[PARTITION BY window_partition]
ORDER BY window_ordering
)
LEAD(value_expr [, offset]) OVER
(
[PARTITION BY window_partition]
ORDER BY window_ordering
) 		LEAD(value_expr [, offset]) OVER
(
[PARTITION BY window_partition]
ORDER BY window_ordering
)
LISTAGG(
[DISTINCT] expression
[, delimiter]
)
[WITHIN GROUP
(ORDER BY order_list)]
OVER (
[PARTITION BY partition_expression] )		 STRING_AGG(
[DISTINCT] aggregate_expression
[, delimiter] )
OVER (
[PARTITION BY partition_list]
[ORDER BY order_list] )
MAX(expression) OVER
(
[PARTITION BY expr_list]
[ORDER BY order_list
frame_clause]
)		 MAX(expression) OVER
(
[PARTITION BY expr_list]
[ORDER BY order_list]
[frame_clause]
)
MEDIAN(median_expression) OVER
(
[PARTITION BY partition_expression] ) 		PERCENTILE_CONT(
median_expression,
0.5
)
OVER ( [PARTITION BY partition_expression] )
MIN(expression) OVER
(
[PARTITION BY expr_list]
[ORDER BY order_list
frame_clause]
)		 MIN(expression) OVER
(
[PARTITION BY expr_list]
[ORDER BY order_list]
[frame_clause]
)
NTH_VALUE(expression, offset) OVER ( [PARTITION BY window_partition] [ORDER BY window_ordering frame_clause] ) NTH_VALUE(expression, offset) OVER
(
[PARTITION BY window_partition]
ORDER BY window_ordering
[frame_clause]
)
NTILE(expr) OVER
(
[PARTITION BY expression_list]
[ORDER BY order_list]
) 		NTILE(expr) OVER
(
[PARTITION BY expression_list]
ORDER BY order_list
)
PERCENT_RANK() OVER
(
[PARTITION BY partition_expression]
[ORDER BY order_list]
) 		PERCENT_RANK() OVER
(
[PARTITION BY partition_expression]
ORDER BY order_list
)
PERCENTILE_CONT(percentile)
WITHIN GROUP (ORDER BY expr) OVER
(
[PARTITION BY expr_list] ) 		PERCENTILE_CONT(expr, percentile) OVER
(
[PARTITION BY expr_list] )
PERCENTILE_DISC(percentile) WITHIN GROUP (ORDER BY expr) OVER
(
[PARTITION BY expr_list]
) 		PERCENTILE_DISC(expr, percentile) OVER
(
[PARTITION BY expr_list] )
RANK() OVER
(
[PARTITION BY expr_list]
[ORDER BY order_list]
)		 RANK() OVER
(
[PARTITION BY expr_list]
ORDER BY order_list
)
RATIO_TO_REPORT(ratio_expression) OVER
(
[PARTITION BY partition_expression] ) 		ratio_expression SUM(ratio_expression) OVER
(
[PARTITION BY partition_expression] )
ROW_NUMBER() OVER
(
[PARTITION BY expr_list]
[ORDER BY order_list]
) 		ROW_NUMBER() OVER
(
[PARTITION BY expr_list]
[ORDER BY order_list]
)
STDDEV(expression) OVER
(
[PARTITION BY expr_list]
[ORDER BY order_list
frame_clause]
)		 STDDEV(expression) OVER
(
[PARTITION BY expr_list]
[ORDER BY order_list]
[frame_clause] )
STDDEV_SAMP(expression) OVER
(
[PARTITION BY expr_list]
[ORDER BY order_list
frame_clause]
)		 STDDEV_SAMP(expression) OVER
(
[PARTITION BY expr_list]
[ORDER BY order_list]
[frame_clause]
)
STDDEV_POP(expression) OVER
(
[PARTITION BY expr_list]
[ORDER BY order_list]
[frame_clause]
) 		STDDEV_POP(expression) OVER
(
[PARTITION BY expr_list]
[ORDER BY order_list]
[frame_clause] )
SUM(expression) OVER
(
[PARTITION BY expr_list]
[ORDER BY order_list]
[frame_clause]
) 		SUM(expression) OVER
(
[PARTITION BY expr_list]
[ORDER BY order_list]
[frame_clause]
)
VAR_POP(expression) OVER
(
[PARTITION BY expr_list]
[ORDER BY order_list]
[frame_clause]
)		 VAR_POP(expression) OVER
(
[PARTITION BY expr_list]
[ORDER BY order_list]
[frame_clause]
)
VAR_SAMP(expression) OVER
(
[PARTITION BY expr_list]
[ORDER BY order_list]
[frame_clause]
) 		VAR_SAMP(expression) OVER
(
[PARTITION BY expr_list]
[ORDER BY order_list]
[frame_clause]
)
VARIANCE(expression) OVER
(
[PARTITION BY expr_list]
[ORDER BY order_list]
[frame_clause]
)		 VARIANCE(expression) OVER
(
[PARTITION BY expr_list]
[ORDER BY order_list]
[frame_clause]
)

条件表达式

下表展示了常见的 Amazon Redshift 条件表达式与其 BigQuery 等效项之间的映射。

Amazon Redshift BigQuery
CASEexpression
WHEN value THEN result
[WHEN...]
[ELSE else_result]
END		 CASE expression
WHEN value THEN result
[WHEN...]
[ELSE else_result]
END
COALESCE(expression1[, ...]) COALESCE(expression1[, ...])
DECODE(
expression,
search1, result1
[, search2, result2...]
[, default]
) 		CASE expression
WHEN value1 THEN result1
[WHEN value2 THEN result2]
[ELSE default]
END
GREATEST(value [, ...]) GREATEST(value [, ...])
LEAST(value [, ...]) LEAST(value [, ...])
NVL(expression1[, ...]) COALESCE(expression1[, ...])
NVL2(
expression,
not_null_return_value,
null_return_value
)		 IF(
expression IS NULL,
null_return_value,
not_null_return_value
)
NULLIF(expression1, expression2) NULLIF(expression1, expression2)

BigQuery 还提供以下条件表达式，这些条件表达式在 Amazon Redshift 中没有直接模拟：

日期和时间函数

下表展示了常见的 Amazon Redshift 日期和时间函数与其 BigQuery 等效项之间的映射。BigQuery 数据和时间函数包括日期函数、日期时间、函数、时间函数和时间戳函数。

请注意，Amazon Redshift 和 BigQuery 中看似相同的函数可能会返回不同的数据类型。

Amazon Redshift BigQuery
ADD_MONTHS(
date,
integer
)		 CAST( DATE_ADD(
date,
INTERVAL integer MONTH
)
AS TIMESTAMP
)
timestamptz_or_timestamp AT TIME ZONE timezone PARSE_TIMESTAMP(
"%c%z",
FORMAT_TIMESTAMP(
"%c%z",
timestamptz_or_timestamp,
timezone
)
)

注意：在解析时间戳或设置时间戳格式以用于显示时，系统会使用时区。字符串格式的时间戳可能包含时区，但当 BigQuery 解析字符串时，会采用等效的世界协调时间 (UTC) 存储该时间戳。如果未明确指定时区，则系统会使用默认时区，即世界协调时间 (UTC)。支持时区名称或相对于世界协调时间 (UTC) 的偏移量 (-HH:MM)，但不支持时区缩写（如 PDT）。
CONVERT_TIMEZONE(
[source_timezone],
target_timezone,
timestamp
)		 PARSE_TIMESTAMP(
"%c%z",
FORMAT_TIMESTAMP(
"%c%z",
timestamp,
target_timezone
)
)

注意：在 BigQuery 中，source_timezone 为世界协调时间 (UTC)。
CURRENT_DATE

注意：采用当前会话时区（默认为世界协调时间 (UTC)）返回当前事务的开始日期。		 CURRENT_DATE()

注意：采用世界协调时间 (UTC) 时区返回当前语句的开始日期。
DATE_CMP(date1, date2) CASE
WHEN date1 = date2 THEN 0
WHEN date1 > date2 THEN 1
ELSE -1
END
DATE_CMP_TIMESTAMP(date1, date2) CASE
WHEN date1 = CAST(date2 AS DATE)
THEN 0
WHEN date1 > CAST(date2 AS DATE)
THEN 1
ELSE -1
END
DATE_CMP_TIMESTAMPTZ(date, timestamptz) CASE
WHEN date > DATE(timestamptz)
THEN 1
WHEN date < DATE(timestamptz)
THEN -1
ELSE 0
END
DATE_PART_YEAR(date) EXTRACT(YEAR FROM date)
DATEADD(date_part, interval, date) CAST(
DATE_ADD(
date,
INTERVAL interval datepart
)
AS TIMESTAMP
)
DATEDIFF(
date_part,
date_expression1,
date_expression2
) 		DATE_DIFF(
date_expression1,
date_expression2,
date_part
)
DATE_PART(date_part, date) EXTRACT(date_part FROM date)
DATE_TRUNC('date_part', timestamp) TIMESTAMP_TRUNC(timestamp, date_part)
EXTRACT(date_part FROM timestamp) EXTRACT(date_part FROM timestamp)
GETDATE() PARSE_TIMESTAMP(
"%c",
FORMAT_TIMESTAMP(
"%c",
CURRENT_TIMESTAMP()
)
)
INTERVAL_CMP(
interval_literal1,
interval_literal2
) 		对于 Redshift 中的间隔，一年中有 360 天。在 BigQuery 中，您可以使用以下用户定义的函数 (UDF) 解析 Redshift 间隔并将其转换为秒。

CREATE TEMP FUNCTION
parse_interval(interval_literal STRING) AS (
(select sum(case
when unit in ('minutes', 'minute', 'm' )
then num * 60
when unit in ('hours', 'hour', 'h') then num
* 60 * 60
when unit in ('days', 'day', 'd' ) then num
* 60 * 60 * 24
when unit in ('weeks', 'week', 'w') then num
* 60 * 60 * 24 * 7
when unit in ('months', 'month' ) then num *
60 * 60 * 24 * 30
when unit in ('years', 'year') then num * 60
* 60 * 24 * 360
else num
end)
from (
select
cast(regexp_extract(value,
r'^[0-9]*\.?[0-9]+') as numeric) num,
substr(value, length(regexp_extract(value,
r'^[0-9]*\.?[0-9]+')) + 1) unit
from
UNNEST(
SPLIT(
replace(
interval_literal, ' ', ''), ',')) value
)));

如需比较间隔字面量，请执行：

IF(
parse_interval(interval_literal1) >
parse_interval(interval_literal2),
1,
IF(
parse_interval(interval_literal1) >
parse_interval(interval_literal2),
-1,
0
)
)
LAST_DAY(date) DATE_SUB(
DATE_ADD(
date,
INTERVAL 1 MONTH
),
INTERVAL 1 DAY
)
MONTHS_BETWEEN(
date1,
date2
) 		DATE_DIFF(
date1,
date2,
MONTH
)
NEXT_DAY(date, day) DATE_ADD(
DATE_TRUNC(
date,
WEEK(day)
),
INTERVAL 1 WEEK
)
SYSDATE

注意：采用当前会话时区（默认为世界协调时间 (UTC)）返回当前事务的开始时间戳。		 CURRENT_TIMESTAMP()

注意：采用世界协调时间 (UTC) 时区返回当前语句的开始时间戳。
TIMEOFDAY() FORMAT_TIMESTAMP(
"%a %b %d %H:%M:%E6S %E4Y %Z",
CURRENT_TIMESTAMP())
TIMESTAMP_CMP(
timestamp1,
timestamp2
)		 CASE
WHEN timestamp1 = timestamp2
THEN 0
WHEN timestamp1 > timestamp2
THEN 1
ELSE -1
END
TIMESTAMP_CMP_DATE(
timestamp,
date
) 		CASE
WHEN
EXTRACT(
DATE FROM timestamp
) = date
THEN 0
WHEN
EXTRACT(
DATE FROM timestamp) > date
THEN 1
ELSE -1
END
TIMESTAMP_CMP_TIMESTAMPTZ(
timestamp,
timestamptz
)

注意：Redshift 会比较采用用户会话定义的时区的时间戳。默认用户会话时区为世界协调时间 (UTC)。		 CASE
WHEN timestamp = timestamptz
THEN 0
WHEN timestamp > timestamptz
THEN 1
ELSE -1
END

注意：BigQuery 会比较采用世界协调时间 (UTC) 时区的时间戳。
TIMESTAMPTZ_CMP(
timestamptz1,
timestamptz2
)

注意：Redshift 会比较采用用户会话定义的时区的时间戳。默认用户会话时区为世界协调时间 (UTC)。		 CASE
WHEN timestamptz1 = timestamptz2
THEN 0
WHEN timestamptz1 > timestamptz2
THEN 1
ELSE -1
END

注意：BigQuery 会比较采用世界协调时间 (UTC) 时区的时间戳。
TIMESTAMPTZ_CMP_DATE(
timestamptz,
date
)

注意：Redshift 会比较采用用户会话定义的时区的时间戳。默认用户会话时区为世界协调时间 (UTC)。		 CASE
WHEN
EXTRACT(
DATE FROM timestamptz) = date
THEN 0
WHEN
EXTRACT(
DATE FROM timestamptz) > date
THEN 1
ELSE -1
END

注意：BigQuery 会比较采用世界协调时间 (UTC) 时区的时间戳。
TIMESTAMPTZ_CMP_TIMESTAMP(
timestamptz,
Timestamp
)

注意：Redshift 会比较采用用户会话定义的时区的时间戳。默认用户会话时区为世界协调时间 (UTC)。		 CASE
WHEN timestamp = timestamptz
THEN 0
WHEN timestamp > timestamptz
THEN 1
ELSE -1
END

注意：BigQuery 会比较采用世界协调时间 (UTC) 时区的时间戳。
TIMEZONE(
timezone,
Timestamptz_or_timestamp
) 		PARSE_TIMESTAMP(
"%c%z", FORMAT_TIMESTAMP(
"%c%z",
timestamptz_or_timestamp,
timezone
)
)

注意：在解析时间戳或设置时间戳格式以用于显示时，系统会使用时区。字符串格式的时间戳可能包含时区，但当 BigQuery 解析字符串时，会采用等效的世界协调时间 (UTC) 存储该时间戳。如果未明确指定时区，则系统会使用默认时区，即世界协调时间 (UTC)。支持时区名称或相对于世界协调时间 (UTC) 的偏移量 (-HH:MM)，但不支持时区缩写（如 PDT）。
TO_TIMESTAMP(timestamp, format) PARSE_TIMESTAMP(
format,
FORMAT_TIMESTAMP(
format,
timestamp
)
)

注意：BigQuery 遵循一组不同的格式元素。在解析时间戳或设置时间戳格式以用于显示时，系统会使用时区。字符串格式的时间戳可能包含时区，但当 BigQuery 解析字符串时，会采用等效的世界协调时间 (UTC) 存储该时间戳。如果未明确指定时区，则系统会使用默认时区，即世界协调时间 (UTC)。格式字符串支持时区名称或相对于世界协调时间 (UTC) 的偏移量 (-HH:MM)，但不支持时区缩写（如 PDT）。
TRUNC(timestamp) CAST(timestamp AS DATE)

BigQuery 还提供以下日期和时间函数，这些函数在 Amazon Redshift 中没有直接模拟：

数学运算符

下表展示了常见的 Amazon Redshift 数学运算符与其 BigQuery 等效项之间的映射。

Amazon Redshift BigQuery

X + Y

X + Y

X - Y

X - Y

X * Y

X * Y

X / Y


注意：如果运算符
执行整数除法（即 X 和 Y 均为整数），则系统会返回整数。如果运算符执行非整数除法，则系统会返回非整数。		 如果是整数除法：
CAST(FLOOR(X / Y) AS INT64)

如果不是整数除法：

CAST(X / Y AS INT64)


注意：BigQuery 中的除法会返回非整数。
为防止除法运算出错（除数为零的错误），请使用 SAFE_DIVIDE(X, Y) 或 IEEE_DIVIDE(X, Y)。

X % Y

MOD(X, Y)


注意：为防止除法运算出错（除数为零的错误），请使用 SAFE.MOD(X, Y)。SAFE.MOD(X, 0) 会导致 0。

X ^ Y

POW(X, Y)

POWER(X, Y)


注意：与 Amazon Redshift 不同，BigQuery 中的 ^ 运算符执行按位异或运算。

| / X

SQRT(X)


注意：为防止平方根运算出错（负输入），请使用 SAFE.SQRT(X)。SAFE.SQRT(X) 为负输入会导致 NULL。

|| / X

SIGN(X) * POWER(ABS(X), 1/3)


注意：如果 X 是小于 0 的有限值且 Y 是非整数，则 BigQuery 的 POWER(X, Y) 会返回错误。

@ X

ABS(X)

X << Y

X << Y


注意：如果第二个操作数 Y 大于或等于第一个操作数 X 的位长度（例如，如果 X 的类型是 INT64，则其位长度是 64），则此运算符会返回 0 或 b'\x00' 字节序列。如果 Y 为负数，则此运算符会抛出错误。

X >> Y

X >> Y


注意：将第一个操作数 X 向右移位。此运算符不会对带符号的类型执行符号位扩展（它会在左侧的空位上填入 0）。如果第二个操作数 Y 大于或
等于第一个操作数 X 的位长度（例如，如果 X 的类型是 INT64，则其位长度是 64），则此运算符返回 0，或者返回 b'\x00' 字节序列。如果 Y 为负，则此运算符引发一个错误。

X & Y

X & Y

X | Y

X | Y

~X

~X

BigQuery 还提供以下数学运算符，该运算符在 Amazon Redshift 中没有直接模拟：

  • X ^ Y（按位异或）

数学函数

Amazon Redshift BigQuery
ABS(number) ABS(number)
ACOS(number) ACOS(number)
ASIN(number) ASIN(number)
ATAN(number) ATAN(number)
ATAN2(number1, number2) ATAN2(number1, number2)
CBRT(number) POWER(number, 1/3)
CEIL(number) CEIL(number)
CEILING(number) CEILING(number)
CHECKSUM(expression) FARM_FINGERPRINT(expression)
COS(number) COS(number)
COT(number) 1/TAN(number)
DEGREES(number) number*180/ACOS(-1)
DEXP(number) EXP(number)
DLOG1(number) LN(number)
DLOG10(number) LOG10(number)
EXP(number) EXP(number)
FLOOR(number) FLOOR(number)
LNnumber) LN(number)
LOG(number) LOG10(number)
MOD(number1, number2) MOD(number1, number2)
PI ACOS(-1)
POWER(expression1, expression2) POWER(expression1, expression2)
RADIANS(number) ACOS(-1)*(number/180)
RANDOM() RAND()
ROUND(number [, integer]) ROUND(number [, integer])
SIN(number) SIN(number)
SIGN(number) SIGN(number)
SQRT(number) SQRT(number)
TAN(number) TAN(number)
TO_HEX(number) FORMAT('%x', number)
TRUNC(number [, integer])+-+++ TRUNC(number [, integer])

字符串函数

Amazon Redshift BigQuery
string1 || string2 CONCAT(string1, string2)
BPCHARCMP(string1, string2) CASE
WHEN string1 = string2 THEN 0
WHEN string1 > string2 THEN 1
ELSE -1
END
BTRIM(string [, matching_string]) TRIM(string [, matching_string])
BTTEXT_PATTERN_CMP(string1, string2) CASE
WHEN string1 = string2 THEN 0
WHEN string1 > string2 THEN 1
ELSE -1
END
CHAR_LENGTH(expression) CHAR_LENGTH(expression)
CHARACTER_LENGTH(expression) CHARACTER_LENGTH(expression)
CHARINDEX(substring, string) STRPOS(string, substring)
CHR(number) CODE_POINTS_TO_STRING([number])
CONCAT(string1, string2) CONCAT(string1, string2)

注意：BigQuery 的 CONCAT(...) 支持
串联任意数量的字符串。
CRC32 自定义用户定义的函数
FUNC_SHA1(string) SHA1(string)
INITCAP INITCAP
LEFT(string, integer) SUBSTR(string, 0, integer)
RIGHT(string, integer) SUBSTR(string, -integer)
LEN(expression) LENGTH(expression)
LENGTH(expression) LENGTH(expression)
LOWER(string) LOWER(string)
LPAD(string1, length[, string2]) LPAD(string1, length[, string2])
RPAD(string1, length[, string2]) RPAD(string1, length[, string2])
LTRIM(string, trim_chars) LTRIM(string, trim_chars)
MD5(string) MD5(string)
OCTET_LENGTH(expression) BYTE_LENGTH(expression)
POSITION(substring IN string) STRPOS(string, substring)
QUOTE_IDENT(string) CONCAT('"',string,'"')
QUOTE_LITERAL(string) CONCAT("'",string,"'")
REGEXP_COUNT( source_string, pattern
[,position]
) 		ARRAY_LENGTH( REGEXP_EXTRACT_ALL(
source_string,
pattern
)
)

如果指定了 position：

ARRAY_LENGTH( REGEXP_EXTRACT_ALL(
SUBSTR(source_string, IF(position <= 0, 1, position)),
pattern
)
)

注意：BigQuery 通过 re2 库提供正则表达式支持；请参阅相关文档了解其正则表达式语法。
REGEXP_INSTR(
source_string,
pattern
[,position
[,occurrence]] ) 		IFNULL( STRPOS(
source_string, REGEXP_EXTRACT(
source_string,
pattern)
),0)

如果指定了 source_string：

REGEXP_REPLACE(
source_string,

pattern,
replace_string
)

如果指定了 position：

IFNULL( STRPOS(
SUBSTR(source_string, IF(position
<= 0, 1, position)), REGEXP_EXTRACT(
SUBSTR(source_string, IF(position <= 0, 1, position)),
pattern)
) + IF(position <= 0, 1, position) - 1, 0)

如果指定了 occurrence：

IFNULL( STRPOS(
SUBSTR(source_string, IF(position
<= 0, 1, position)), REGEXP_EXTRACT_ALL(
SUBSTR(source_string, IF(position <= 0, 1, position)),
pattern
)[SAFE_ORDINAL(occurrence)]
) + IF(position <= 0, 1, position) - 1, 0)

注意：BigQuery 通过
re2 库提供正则表达式支持；请参阅相关文档
了解其正则表达式语法
。
REGEXP_REPLACE( source_string,
pattern
[, replace_string [, position]]
) 		REGEXP_REPLACE(
source_string,
pattern,
""
)

如果指定了 source_string：

REGEXP_REPLACE(
source_string,

pattern, replace_string
)

如果指定了 position：

CASE
WHEN position > LENGTH(source_string) THEN source_string
WHEN position <= 0 THEN REGEXP_REPLACE(
source_string, pattern,
""
) ELSE
CONCAT( SUBSTR(
source_string, 1, position - 1), REGEXP_REPLACE(