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 在剖析字串時，會將時間戳記儲存為對應的世界標準時間。如果未明確指定時區，系統會使用預設時區 (世界標準時間)。系統支援時區名稱或與世界標準時間的時差 (-|+)HH:MM，但不支援時區縮寫，例如太平洋夏令時間 (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 都支援下列類型的聯結：

下表列出一些細微差異。

Amazon Redshift BigQuery

SELECT col
FROM table1
NATURAL INNER JOIN
table2

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


注意：在 BigQuery 中，JOIN 子句需要 JOIN 條件，除非子句是 CROSS 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 語法，但預設會排序所有資料列，因此行為與 Amazon Redshift 的 LIMIT ALL 子句相同。ORDER BY我們強烈建議在每個 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 在剖析字串時，會將時間戳記儲存為對應的世界標準時間。如果未明確指定時區，系統會使用預設時區 (世界標準時間)。系統支援時區名稱或與世界標準時間的時差 (-HH:MM)，但不支援時區縮寫 (例如太平洋夏令時間)。
CONVERT_TIMEZONE(
[source_timezone],
target_timezone,
timestamp
)		 PARSE_TIMESTAMP(
"%c%z",
FORMAT_TIMESTAMP(
"%c%z",
timestamp,
target_timezone
)
)

注意：BigQuery 中的 source_timezone 是世界標準時間。
CURRENT_DATE

注意：傳回目前交易的開始日期，時區為目前工作階段時區 (預設為世界標準時間)。		 CURRENT_DATE()

注意：傳回目前對帳單在世界標準時間時區的開始日期。
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

注意：傳回目前交易的開始時間戳記，時區為目前工作階段時區 (預設為世界標準時間)。		 CURRENT_TIMESTAMP()

注意：傳回目前陳述式在世界標準時間時區中的開始時間戳記。
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 會比較使用者工作階段定義時區中的時間戳記。預設使用者工作階段時區為世界標準時間。		 CASE
WHEN timestamp = timestamptz
THEN 0
WHEN timestamp > timestamptz
THEN 1
ELSE -1
END

注意：BigQuery 會比較世界標準時間時區中的時間戳記。
TIMESTAMPTZ_CMP(
timestamptz1,
timestamptz2
)

注意：Redshift 會比較使用者工作階段定義時區中的時間戳記。預設使用者工作階段時區為世界標準時間。		 CASE
WHEN timestamptz1 = timestamptz2
THEN 0
WHEN timestamptz1 > timestamptz2
THEN 1
ELSE -1
END

注意：BigQuery 會比較世界標準時間時區中的時間戳記。
TIMESTAMPTZ_CMP_DATE(
timestamptz,
date
)

注意：Redshift 會比較使用者工作階段定義時區中的時間戳記。預設使用者工作階段時區為世界標準時間。		 CASE
WHEN
EXTRACT(
DATE FROM timestamptz) = date
THEN 0
WHEN
EXTRACT(
DATE FROM timestamptz) > date
THEN 1
ELSE -1
END

注意：BigQuery 會比較世界標準時間時區中的時間戳記。
TIMESTAMPTZ_CMP_TIMESTAMP(
timestamptz,
Timestamp
)

注意：Redshift 會比較使用者工作階段定義時區中的時間戳記。預設使用者工作階段時區為世界標準時間。		 CASE
WHEN timestamp = timestamptz
THEN 0
WHEN timestamp > timestamptz
THEN 1
ELSE -1
END

注意：BigQuery 會比較世界標準時間時區中的時間戳記。
TIMEZONE(
timezone,
Timestamptz_or_timestamp
) 		PARSE_TIMESTAMP(
"%c%z", FORMAT_TIMESTAMP(
"%c%z",
timestamptz_or_timestamp,
timezone
)
)

注意：剖析時間戳記或設定時間戳記的格式以供顯示時，會使用時區。字串格式的時間戳記可能包含時區，但 BigQuery 在剖析字串時，會將時間戳記儲存為對應的世界標準時間。如果未明確指定時區，系統會使用預設時區 (世界標準時間)。系統支援時區名稱或與世界標準時間的時差 (-HH:MM)，但不支援時區縮寫 (例如 PDT)。
TO_TIMESTAMP(timestamp, format) PARSE_TIMESTAMP(
format,
FORMAT_TIMESTAMP(
format,
timestamp
)
)

注意：BigQuery 遵循不同的格式元素。剖析時間戳記或設定時間戳記的格式以供顯示時，會使用時區。字串格式的時間戳記可能包含時區，但 BigQuery 在剖析字串時，會將時間戳記儲存為對應的世界標準時間。如果未明確指定時區，系統會使用預設時區 (世界標準時間)。格式字串支援時區名稱或與世界標準時間的時差 (-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) 筆結果，

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 的位元長度，這個運算子就會傳回 0，或是 b'\x00' 的位元組序列 (舉例來說，如果 X 有類型 INT64，這個運算子就會傳回 64)。如果 Y 為負數，這個運算子會擲回錯誤。

X >> Y

X >> Y


注意：將第一個運算元 X 向右移。這個運算子不會對帶正負號的類型執行正負號位元擴充 (它會在左側的空位元填入 0)。如果第二個運算元 Y 的位元長度大於或等於第一個運算元 X 的位元長度，這個運算子就會傳回 0，或是 b'\x00' 的位元組序列 (舉例來說，如果 X 有類型 INT64，這個運算子就會傳回 64)。
如果 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(
SUBSTR(source_string, position), pattern,
replace_string
)
) END
REGEXP_SUBSTR( source_string, pattern
[, position
[, occurrence]] ) 		REGEXP_EXTRACT(
source_string, pattern
)

如果指定 position：

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

)

如果指定 occurrence：

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


pattern
)[SAFE_ORDINAL(occurrence)]

注意：BigQuery 使用 re2 程式庫，因此支援規則運算式。如要瞭解規則運算式語法，請參閱相關說明文件。
REPEAT(string, integer) REPEAT(string, integer)
REPLACE(string, old_chars, new_chars) REPLACE(string, old_chars, new_chars)
REPLICA(string, integer) REPEAT(string, integer)
REVERSE(expression) REVERSE(expression)
RTRIM(string, trim_chars) RTRIM(string, trim_chars)
SPLIT_PART(string, delimiter, part) SPLIT(
string
delimiter
)SAFE_ORDINAL(part)
STRPOS(string, substring) STRPOS(string, substring)
STRTOL(string, base)
SUBSTRING(
string,
start_position, number_characters ) 		SUBSTR(
string,
start_position, number_characters )
TEXTLEN(expression) LENGTH(expression)
TRANSLATE(
expression,
characters_to_replace, characters_to_substitute ) 		可使用 UDF 實作：

CREATE TEMP FUNCTION
translate(expression STRING,
characters_to_replace STRING, characters_to_substitute STRING) AS ( IF(LENGTH(characters_to_replace) < LENGTH(characters_to_substitute) OR LENGTH(expression) <
LENGTH(characters_to_replace), expression,
(SELECT
STRING_AGG(
IFNULL(
(SELECT ARRAY_CONCAT([c],
SPLIT(characters_to_substitute, ''))[SAFE_OFFSET((
SELECT IFNULL(MIN(o2) + 1,
0) FROM
UNNEST(SPLIT(characters_to_replace,
'')) AS k WITH OFFSET o2
WHERE k = c))]
),
''),
'' ORDER BY o1)
FROM UNNEST(SPLIT(expression, ''))
AS c WITH OFFSET o1
))
);
TRIM([BOTH] string) TRIM(string)
TRIM([BOTH] characters FROM string) TRIM(string, characters)
UPPER(string) UPPER(string)

資料類型格式設定函式

Amazon Redshift BigQuery
CAST(expression AS type) CAST(expression AS type)
expression :: type CAST(expression AS type)
CONVERT(type, expression) CAST(expression AS type)
TO_CHAR(
timestamp_expression, format
)		 FORMAT_TIMESTAMP(
format,
timestamp_expression
)

注意：BigQuery 和 Amazon Redshift 指定 timestamp_expression 的格式字串方式不同。
TO_CHAR(
numeric_expression,
format
)		 FORMAT(
format,
numeric_expression
)

注意：BigQuery 和 Amazon Redshift 指定 timestamp_expression 的格式字串方式不同。
TO_DATE(date_string, format) PARSE_DATE(date_string, format)

注意：BigQuery 和 Amazon Redshift 指定 date_string 格式字串的方式不同。
TO_NUMBER(string, format) CAST(
FORMAT(
format,
numeric_expression
) TO INT64
)

注意：BigQuery 和 Amazon Redshift 指定數值格式字串的方式不同。

BigQuery 也支援 SAFE_CAST(expression AS typename)，如果 BigQuery 無法執行轉換，則會傳回 NULL；例如，SAFE_CAST("apple" AS INT64) 會傳回 NULL。

DML 語法

本節說明 Amazon Redshift 和 BigQuery 之間資料管理語言語法的差異。

INSERT 陳述式

Amazon Redshift 提供可設定的 DEFAULT 欄位關鍵字。在 BigQuery 中，可為空值的資料欄的 DEFAULT 值為 NULL，且必要資料欄不支援 DEFAULT。大多數 Amazon Redshift INSERT 陳述式都與 BigQuery 相容。下表列出例外狀況。

Amazon Redshift BigQuery
INSERT INTO table (column1 [, ...])
DEFAULT VALUES		 INSERT [INTO] table (column1 [, ...])
VALUES (DEFAULT [, ...])
INSERT INTO table (column1, [,...]) VALUES (
SELECT ...
FROM ...
)		 INSERT [INTO] table (column1, [,...])
SELECT ...
FROM ...

BigQuery 也支援使用子查詢插入值 (其中一個值是透過子查詢計算)，但 Amazon Redshift 不支援這項功能。例如：

INSERT INTO table (column1, column2)
VALUES ('value_1', (
SELECT column2
FROM table2
))

COPY 陳述式

Amazon Redshift 的 COPY 指令會從資料檔案或 Amazon DynamoDB 資料表，將資料載入至資料表。BigQuery 不會使用 SQL COPY 指令載入資料，但您可以透過多種非 SQL 工具和選項，將資料載入 BigQuery 表格。您也可以使用 Apache Spark 或 Apache Beam 中提供的資料管道接收器，將資料寫入 BigQuery。

UPDATE 陳述式

大多數 Amazon Redshift UPDATE 陳述式都與 BigQuery 相容。下表列出例外狀況。

Amazon Redshift BigQuery
UPDATE table
SET column = expression [,...] [FROM ...] 		UPDATE table
SET column = expression [,...]
[FROM ...]
WHERE TRUE

注意：BigQuery 中的所有 UPDATE 陳述式都必須包含 WHERE 關鍵字，後接條件。
UPDATE table
SET column = DEFAULT [,...] [FROM ...]
[WHERE ...]		 UPDATE table
SET column = NULL [, ...]
[FROM ...]
WHERE ...

注意：BigQuery 的 UPDATE 指令不支援 DEFAULT 值。

如果 Amazon Redshift UPDATE 陳述式未包含 WHERE 子句，則 BigQuery UPDATE 陳述式應為條件 WHERE TRUE。

DELETE 和 TRUNCATE 陳述式

DELETE 和 TRUNCATE 陳述式都能從資料表移除資料列，且不會影響資料表結構定義或索引。

在 Amazon Redshift 中，建議使用 TRUNCATE 陳述式，而非不合格的 DELETE 陳述式，因為前者速度較快，且後續不需要 VACUUM 和 ANALYZE 作業。不過，您可以使用 DELETE 陳述式達到相同效果。

在 BigQuery 中，DELETE 陳述式必須有 WHERE 子句。如要進一步瞭解 BigQuery 中的 DELETE，請參閱 DML 說明文件中的 BigQuery DELETE 範例。

Amazon Redshift BigQuery
DELETE [FROM] table_name

TRUNCATE [TABLE] table_name		 DELETE FROM table_name
WHERE TRUE

BigQuery DELETE 陳述式必須包含 WHERE 子句。
DELETE FROM table_name
USING other_table
WHERE table_name.id=other_table.id		 DELETE FROM table_name
WHERE table_name.id IN (
SELECT id
FROM other_table
)

DELETE FROM table_name
WHERE EXISTS (
SELECT id
FROM other_table
WHERE table_name.id = other_table.id )

在 Amazon Redshift 中，USING 允許在 WHERE 子句中參照其他資料表。您可以在 WHERE 子句中使用子查詢，在 BigQuery 中完成這項作業。

MERGE 陳述式

MERGE 陳述式可將 INSERT、UPDATE 和 DELETE 作業結合成單一 upsert 陳述式，並以不可分割的形式執行這些作業。每個目標資料列的 MERGE 作業最多只能與一個來源資料列相符。

Amazon Redshift 不支援單一 MERGE 指令。不過，您可以在 Amazon Redshift 中執行合併作業，方法是在交易中執行 INSERT、UPDATE 和 DELETE 作業。

透過取代現有資料列進行合併作業

在 Amazon Redshift 中，您可以使用 DELETE 陳述式，然後使用 INSERT 陳述式，覆寫目標資料表中的所有資料欄。DELETE 陳述式會移除應更新的資料列，然後 INSERT 陳述式會插入更新後的資料列。BigQuery 資料表每天最多只能有 1,000 個 DML 陳述式，因此您應將 INSERT、UPDATE 和 DELETE 陳述式合併為單一 MERGE 陳述式，如下表所示。

Amazon Redshift BigQuery
請參閱透過 取代現有資料列執行合併作業。

CREATE TEMP TABLE temp_table;

INSERT INTO temp_table
SELECT *
FROM source
WHERE source.filter = 'filter_exp';

BEGIN TRANSACTION;

DELETE FROM target
USING temp_table
WHERE target.key = temp_table.key;

INSERT INTO target
SELECT *
FROM temp_table;

END TRANSACTION;

DROP TABLE temp_table; 		MERGE target
USING source
ON target.key = source.key
WHEN MATCHED AND source.filter = 'filter_exp' THEN
UPDATE SET
target.col1 = source.col1,
target.col2 = source.col2,
...

注意：如要更新所有資料欄，必須列出所有資料欄。
請參閱這篇文章，瞭解如何指定欄清單來執行合併作業。

CREATE TEMP TABLE temp_table;

INSERT INTO temp_table
SELECT *
FROM source
WHERE source.filter = 'filter_exp';

BEGIN TRANSACTION;

UPDATE target SET
col1 = temp_table.col1,
col2 = temp_table.col2
FROM temp_table
WHERE target.key=temp_table.key;

INSERT INTO target
SELECT *
FROM 		MERGE target
USING source
ON target.key = source.key
WHEN MATCHED AND source.filter = 'filter_exp' THEN
UPDATE SET
target.col1 = source.col1,
target.col2 = source.col2

DDL 語法

本節說明 Amazon Redshift 和 BigQuery 之間資料定義語言語法的差異。

SELECT INTO 陳述式

在 Amazon Redshift 中，SELECT INTO 陳述式可用於將查詢結果插入新資料表，同時建立資料表並插入資料。

Amazon Redshift BigQuery
SELECT expression, ... INTO table
FROM ... 		INSERT table
SELECT expression, ...
FROM ...
WITH subquery_table AS ( SELECT ...
)
SELECT expression, ... INTO table
FROM subquery_table
... 		INSERT table
WITH subquery_table AS (
SELECT ...
)
SELECT expression, ...
FROM subquery_table
...
SELECT expression
INTO TEMP table
FROM ...

SELECT expression
INTO TEMPORARY table
FROM ... 		BigQuery 提供多種方式來模擬臨時資料表。詳情請參閱暫時性資料表一節。

CREATE TABLE 陳述式

大多數 Amazon Redshift 陳述式都與 BigQuery 相容，但下列語法元素除外，因為 BigQuery 不會使用這些元素： CREATE TABLE

Amazon Redshift BigQuery
CREATE TABLE table_name (
col1 data_type1 NOT NULL,
col2 data_type2 NULL,
col3 data_type3 UNIQUE,
col4 data_type4 PRIMARY KEY,
col5 data_type5
)

注意：UNIQUE 和 PRIMARY KEY 限制僅供參考，Amazon Redshift 系統 不會強制執行。		 CREATE TABLE table_name (
col1 data_type1 NOT NULL,
col2 data_type2,
col3 data_type3,
col4 data_type4,
col5 data_type5,
)
CREATE TABLE table_name
(
col1 data_type1[,...]
table_constraints
)
where table_constraints are:
[UNIQUE(column_name [, ... ])]
[PRIMARY KEY(column_name [, ...])]
[FOREIGN KEY(column_name [, ...])
REFERENCES reftable [(refcolumn)]

注意：UNIQUE 和 PRIMARY KEY 限制僅供參考，Amazon Redshift 系統不會強制執行這些限制。 		CREATE TABLE table_name
(
col1 data_type1[,...]
)
PARTITION BY column_name
CLUSTER BY column_name [, ...]

注意：BigQuery 不會使用 UNIQUE、PRIMARY KEY 或 FOREIGN KEY 資料表限制。如要達到類似的最佳化效果，請在執行查詢時，對 BigQuery 資料表進行分區和分群。CLUSTER BY 最多支援 4 個資料欄。
CREATE TABLE table_name
LIKE original_table_name 		請參閱這個範例，瞭解如何使用 INFORMATION_SCHEMA 資料表將資料欄名稱、資料類型和 NOT NULL 限制複製到新資料表。
CREATE TABLE table_name
(
col1 data_type1
)
BACKUP NO

注意：在 Amazon Redshift 中，系統會指定 BACKUP NO 設定，以節省處理時間並減少儲存空間。		 BigQuery 會自動保留所有資料表最多 7 天的歷史版本，且不會影響處理時間或計費儲存空間，因此不需要使用或設定 BACKUP NO 資料表選項。
CREATE TABLE table_name
(
col1 data_type1
)
table_attributes
where table_attributes are:
[DISTSTYLE {AUTO|EVEN|KEY|ALL}]
[DISTKEY (column_name)]
[[COMPOUND|INTERLEAVED] SORTKEY
(column_name [, ...])] 		BigQuery 支援叢集，可依排序順序儲存鍵。
CREATE TABLE table_name
AS SELECT ... 		CREATE TABLE table_name
AS SELECT ...
CREATE TABLE IF NOT EXISTS table_name ... CREATE TABLE IF NOT EXISTS
table_name
...

BigQuery 也支援 DDL 陳述式 CREATE OR REPLACE TABLE，如果資料表已存在，系統會覆寫該資料表。

BigQuery 的 CREATE TABLE 陳述式也支援下列子句，這些子句在 Amazon Redshift 中沒有對應項目：

如要進一步瞭解 BigQuery 中的 CREATE TABLE，請參閱 DML 說明文件中的 BigQuery CREATE TABLE 範例。

臨時資料表

Amazon Redshift 支援暫時性資料表，這類資料表只會在目前的工作階段中顯示。在 BigQuery 中模擬臨時資料表的方法有幾種：

  • 資料集存留時間：建立存留時間較短的資料集 (例如一小時)，這樣一來，資料集中建立的任何資料表都會成為暫時性資料表，因為這些資料表的存留時間不會超過資料集的存留時間。您可以在這個資料集中，為所有資料表名稱加上 temp 前置字元，清楚標示這些資料表是暫時性的。

  • 資料表 TTL：使用類似下列的 DDL 陳述式，建立具有資料表專屬短暫存留時間的資料表：

    CREATE TABLE
temp.name (col1, col2, ...)
OPTIONS (expiration_timestamp=TIMESTAMP_ADD(CURRENT_TIMESTAMP(),
INTERVAL 1 HOUR));

CREATE VIEW 陳述式

下表列出 Amazon Redshift 和 BigQuery 中 CREATE VIEW 陳述式的對應項目。

Amazon Redshift BigQuery
CREATE VIEW view_name AS SELECT ...code> CREATE VIEW view_name AS SELECT ...
CREATE OR REPLACE VIEW view_name AS SELECT ... CREATE OR REPLACE VIEW
view_name AS
SELECT ...
CREATE VIEW view_name
(column_name, ...)
AS SELECT ... 		CREATE VIEW view_name AS SELECT ...
不支援。 CREATE VIEW IF NOT EXISTS c view_name
OPTIONS(view_option_list)
AS SELECT …

只有在指定資料集內沒有檢視表時，才會建立新的檢視表。
CREATE VIEW view_name
AS SELECT ...
WITH NO SCHEMA BINDING

在 Amazon Redshift 中，您必須使用延遲繫結檢視畫面，才能參照外部資料表。		 在 BigQuery 中建立檢視表時，所有參照的物件都必須已存在。

BigQuery 可讓您查詢外部資料來源。

使用者定義的函式 (UDF)

您可以透過 UDF 建立函式，執行自訂作業。這些函式會接受輸入資料欄並執行各項動作，再以值形式傳回這些動作的結果。

Amazon Redshift 和 BigQuery 都支援使用 SQL 運算式的 UDF。此外，您可以在 Amazon Redshift 中建立以 Python 為基礎的 UDF，在 BigQuery 中建立以 JavaScript 為基礎的 UDF。

如需常見 BigQuery UDF 的程式庫，請參閱 Google Cloud BigQuery 公用程式 GitHub 存放區。

CREATE FUNCTION 語法

下表說明 Amazon Redshift 和 BigQuery 之間 SQL UDF 建立語法的差異。

Amazon Redshift BigQuery
CREATE [OR REPLACE] FUNCTION
function_name
([sql_arg_name sql_arg_data_type[,..]]) RETURNS data_type
IMMUTABLE
AS $$
sql_function_definition
$$ LANGUAGE sql 		CREATE [OR REPLACE] FUNCTION
function_name
([sql_arg_name sql_arg_data_type[,..]]) AS
sql_function_definition

注意：在 BigQuery SQL UDF 中，傳回資料類型為選用項目。當查詢呼叫函式時，BigQuery 會從 SQL 函式主體推測出函式的結果類型。
CREATE [OR REPLACE] FUNCTION
function_name
([sql_arg_name sql_arg_data_type[,..]]) RETURNS data_type
{ VOLATILE | STABLE | IMMUTABLE } AS $$
sql_function_definition
$$ LANGUAGE sql 		CREATE [OR REPLACE] FUNCTION
function_name
([sql_arg_name sql_arg_data_type[,..]]) RETURNS data_type
AS sql_function_definition

注意：函式變動性不是 BigQuery 中的可設定參數。所有 BigQuery UDF 變動性都等同於 Amazon Redshift 的變動性 (也就是說，不會進行資料庫查詢，也不會使用引數清單中未直接提供的資訊)。IMMUTABLE
CREATE [OR REPLACE] FUNCTION
function_name
([sql_arg_name sql_arg_data_type[,..]]) RETURNS data_type
IMMUTABLE
AS $$
SELECT_clause
$$ LANGUAGE sql

注意：Amazon Redshift 僅支援 SQL SELECT 子句做為函式定義。此外，SELECT 子句不得包含任何 FROM, INTO, WHERE, GROUP BY, ORDER BY, 和 LIMIT 子句。		 CREATE [OR REPLACE] FUNCTION
function_name
([sql_arg_name sql_arg_data_type[,..]]) RETURNS data_type
AS sql_expression

注意：BigQuery 支援任何 SQL 運算式做為函式定義。 不過，系統不支援參照資料表、檢視區塊或模型。
CREATE [OR REPLACE] FUNCTION
function_name
([sql_arg_name sql_arg_data_type[,..]]) RETURNS data_type
IMMUTABLE
AS $$
sql_function_definition
$$ LANGUAGE sql 		CREATE [OR REPLACE] FUNCTION function_name ([sql_arg_name sql_arg_data_type[,..]]) RETURNS data_type AS sql_function_definition

注意：GoogleSQL UDF 不必指定語言常值。 BigQuery 預設會解讀 SQL 運算式。此外，Amazon Redshift 貨幣引號 ($$) is not supported in BigQuery.
CREATE [OR REPLACE] FUNCTION function_name (integer, integer) RETURNS integer IMMUTABLE AS $$ SELECT $1 + $2 $$ LANGUAGE sql CREATE [OR REPLACE] FUNCTION
function_name
(x INT64, y INT64)
RETURNS INT64
AS
SELECT x + y

Note: BigQuery UDFs require all input arguments to be named. The Amazon Redshift argument variables ($1, $2, …) are not supported in BigQuery.
CREATE [OR REPLACE] FUNCTION
function_name
(integer, integer)
RETURNS integer
IMMUTABLE
AS $$
SELECT $1 + $2
$$ LANGUAGE sql

Note: Amazon Redshift does not support ANY TYPE for SQL UDFs. However, it supports using the ANYELEMENT data type in Python-based UDFs. 		CREATE [OR REPLACE] FUNCTION
function_name
(x ANY TYPE, y ANY TYPE)
AS
SELECT x + y

Note: BigQuery supports using ANY TYPE as argument type. The function accepts an input of any type for this argument. For more information, see templated parameter in BigQuery.

BigQuery also supports the CREATE FUNCTION IF NOT EXISTS statement, which treats the query as successful and takes no action if a function with the same name already exists.

BigQuery's CREATE FUNCTION statement also supports creating TEMPORARY or TEMP functions, which do not have an Amazon Redshift equivalent.

See calling UDFs for details on executing a BigQuery-persistent UDF.

DROP FUNCTION syntax

The following table addresses differences in DROP FUNCTION syntax between Amazon Redshift and BigQuery.

Amazon Redshift BigQuery
DROP FUNCTION
function_name
( [arg_name] arg_type [, ...] ) [ CASCADE | RESTRICT ]		 DROP FUNCTION
dataset_name.function_name

Note: BigQuery does not require using the function's signature for deleting the function. Also, removing function dependencies is not supported in BigQuery.

BigQuery also supports the DROP FUNCTION IF EXISTS statement, which deletes the function only if the function exists in the specified dataset.

BigQuery requires that you specify the project_name if the function is not located in the current project.

UDF components

This section highlights the similarities and differences in UDF components between Amazon Redshift andBigQuery.

Component Amazon Redshift BigQuery
Name Amazon Redshift recommends using the prefix _f for function names to avoid conflicts with existing or future built-in SQL function names. In BigQuery, you can use any custom function name.
Arguments Arguments are optional. You can use name and data types for Python UDF arguments and only data types for SQL UDF arguments. In SQL UDFs, you must refer to arguments using $1, $2, and so on. Amazon Redshift also restricts the number of arguments to 32. Arguments are optional, but if you specify arguments, they must use both name and data types for both JavaScript and SQL UDFs. The maximum number of arguments for a persistent UDF is 256.
Data type Amazon Redshift supports a different set of data types for SQL and Python UDFs.
For a Python UDF, the data type might also be ANYELEMENT.

You must specify a RETURN data type for both SQL and Python UDFs.

See Data types in this document for equivalents between data types in Amazon Redshift and in BigQuery.		 BigQuery supports a different set of data types for SQL and JavaScript UDFs.
For a SQL UDF, the data type might also be ANY TYPE. For more information, see templated parameters in BigQuery.

The RETURN data type is optional for SQL UDFs.

See Supported JavaScript UDF data types for information on how BigQuery data types map to JavaScript data types.
Definition For both SQL and Python UDFs, you must enclose the function definition using dollar quoting, as in a pair of dollar signs ($$) 可表示函式陳述式的開頭和結尾。

如果是 SQL UDF，Amazon Redshift 僅支援以 SQL SELECT 子句做為函式定義。此外，SELECT 子句不得包含任何 FROM、INTO、WHERE、GROUP
、BY、ORDER BY 和 LIMIT 子句。

如要使用 Python UDF，您可以透過 Python 2.7 標準程式庫編寫 Python 程式，也可以使用 CREATE LIBRARY 指令建立自訂模組並匯入。		 在 BigQuery 中，您必須使用引號包覆 JavaScript 程式碼。詳情請參閱引用 規則。

如為 SQL UDF，您可以使用任何 SQL 運算式做為函式定義。不過，BigQuery 不支援參照資料表、檢視區塊或模型。

如果是 JavaScript UDF，您可以使用 OPTIONS 區段直接加入 外部程式碼資料庫。您也可以使用 BigQuery UDF 測試工具測試函式。
語言 您必須使用 LANGUAGE 常值指定語言，SQL UDF 為 sql ，Python UDF 則為 plpythonu 。 您不需要為 SQL UDF 指定 LANGUAGE ，但必須為 JavaScript UDF 指定語言 js 。
狀態 Amazon Redshift 不支援建立暫時性 UDF。

Amazon Redshift 提供選項，可使用 VOLATILE、STABLE 或 IMMUTABLE 常值定義函式的波動性。查詢最佳化工具會使用這項資訊進行最佳化。		 BigQuery 支援永久和暫時 UDF。您可以在多個查詢中重複使用永久性 UDF，但只能將暫時性 UDF 用於單一查詢。

BigQuery 無法設定函式變動性參數。所有 BigQuery UDF 變動性都等同於 Amazon Redshift 的 IMMUTABLE 變動性。
安全性與權限 如要建立 UDF，您必須具備 SQL 或 plpythonu (Python) 的語言使用權限。根據預設，USAGE ON LANGUAGE SQL 會授予 PUBLIC，但您必須明確將 USAGE ON LANGUAGE PLPYTHONU 授予特定使用者或群組。
此外，您必須是超級使用者，才能取代 UDF。		 在 BigQuery 中，您不必明確授予建立或刪除任何類型 UDF 的權限。獲派 BigQuery 資料編輯者角色的使用者 (擁有 bigquery.routines.* 權限)，可以為指定資料集建立或刪除函式。

BigQuery 也支援建立自訂角色。這項設定可使用 Cloud IAM 管理。
限制 請參閱 Python UDF 限制。 請參閱使用者定義函式的限制。

中繼資料和交易 SQL 陳述式

Amazon Redshift BigQuery
SELECT * FROM STL_ANALYZE WHERE name
= 'T';		 BigQuery 未使用。您不需要收集統計資料，即可提高查詢效能。如要取得資料分配情形的相關資訊，可以使用近似匯總函式。
ANALYZE [[ table_name[(column_name
[, ...])]]		 BigQuery 未使用。
LOCK TABLE table_name; BigQuery 未使用。
BEGIN TRANSACTION; SELECT ...
END TRANSACTION;		 BigQuery 使用快照隔離。詳情請參閱「一致性保證」。
EXPLAIN ... BigQuery 未使用。

類似功能包括 BigQuery Google Cloud 控制台中的查詢計畫說明，以及 Cloud Monitoring 中的稽核記錄。
SELECT * FROM SVV_TABLE_INFO WHERE
table = 'T';		 SELECT * EXCEPT(is_typed) FROM
mydataset.INFORMATION_SCHEMA.TABLES;

詳情請參閱 BigQuery 簡介 INFORMATION_SCHEMA。
VACUUM [table_name] BigQuery 未使用。BigQuery 叢集資料表會自動排序。

多陳述式和多行 SQL 陳述式

Amazon Redshift 和 BigQuery 都支援交易 (工作階段)，因此支援以半形分號分隔的陳述式，這些陳述式會一併執行。詳情請參閱「多重陳述式交易」。

程序化 SQL 陳述式

CREATE PROCEDURE 陳述式

Amazon Redshift BigQuery
CREATE or REPLACE PROCEDURE CREATE PROCEDURE (如果需要名稱)。

否則，請使用內嵌的 BEGIN，或使用單行的 CREATE TEMP FUNCTION。
CALL CALL

變數宣告和指派

Amazon Redshift BigQuery
DECLARE DECLARE

宣告指定類型的變數。
SET SET

將變數設為具有所提供運算式的值，或是依據多個運算式的結果，同時設定多個變數。

錯誤狀況處理常式

在 Amazon Redshift 中，執行預存程序時發生錯誤會導致執行流程和交易終止，並回溯交易。這是因為系統不支援子交易。在 Amazon Redshift 預存程序中，唯一支援的 handler_statement 是 RAISE。在 BigQuery 中，錯誤處理是主要控制流程的核心功能，類似於其他語言透過 TRY ... CATCH 區塊提供的功能。

Amazon Redshift BigQuery
BEGIN ... EXCEPTION WHEN OTHERS THEN BEGIN ... EXCEPTION WHEN ERROR THEN
RAISE RAISE
[ <<label>> ] [ DECLARE declarations ]
BEGIN
statements EXCEPTION
BEGIN
statements
EXCEPTION
WHEN OTHERS THEN
Handler_statements
END;		 BEGIN
BEGIN
...
EXCEPTION WHEN ERROR THEN SELECT 1/0;
END;

EXCEPTION WHEN ERROR THEN -- The exception thrown from the inner exception handler lands here. END;

游標宣告和作業

由於 BigQuery 不支援游標或工作階段，因此 BigQuery 不會使用下列陳述式：

如果您使用游標傳回結果集，可以在 BigQuery 中使用暫時資料表，達到類似的行為。

動態 SQL 陳述式

BigQuery 的指令碼功能支援動態 SQL 陳述式，如下表所示。

Amazon Redshift BigQuery
EXECUTE EXECUTE IMMEDIATE

控制流程陳述式

Amazon Redshift BigQuery
IF..THEN..ELSIF..THEN..ELSE..END IF IF condition
THEN stmts
ELSE stmts
END IF
name CURSOR [ ( arguments ) ] FOR query BigQuery 不會使用游標或工作階段。
[< LOOP
sql_statement_list END LOOP;
WHILE condition LOOP stmts END LOOP WHILE condition
DO stmts
END WHILE
EXIT BREAK

一致性保證和交易隔離

Amazon Redshift 和 BigQuery 都是不可分割的，也就是說，在多個資料列中，每個變動層級都符合 ACID 標準。

交易

Amazon Redshift 預設支援交易的可序列化隔離。Amazon Redshift 可讓您指定四種 SQL 標準交易隔離層級的任一項，但會將所有隔離層級視為可序列化。

BigQuery 也支援交易。BigQuery 採用快照 隔離機制，確保樂觀並行控制 (優先提交者優先)，查詢會讀取查詢開始前最後提交的資料。這種做法可確保每個資料列和每個變異，以及相同 DML 陳述式中的資料列，都具有相同的一致性，同時避免死結。如果對同一個資料表進行多次 DML 更新，BigQuery 會改用悲觀並行控制。載入工作可以完全獨立執行，並附加至資料表。

復原

如果 Amazon Redshift 在執行預存程序時發生任何錯誤，系統會復原交易中進行的所有變更。此外，您可以在預存程序中使用 ROLLBACK 交易控制陳述式，捨棄所有變更。

在 BigQuery 中，您可以使用 ROLLBACK TRANSACTION 陳述式。

資料庫限制

如要瞭解最新配額和限制，請參閱 BigQuery 公開說明文件。大量使用者的許多配額都可以透過聯絡 Cloud 支援團隊來提高。下表比較 Amazon Redshift 和 BigQuery 的資料庫限制。

限制 Amazon Redshift BigQuery
大型和特大型叢集節點類型中每個資料庫的資料表 9,900 未限制
各資料庫的 8xlarge 叢集節點類型資料表 20,000 未限制
您可以為每個叢集建立的使用者定義資料庫 60 未限制
資料列大小上限 4 MB 100 MB