本頁面由 Cloud Translation API 翻譯而成。

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 也支援其他資料表參照：

使用 FOR SYSTEM_TIME AS OF 的資料表定義和資料列歷史版本。
欄位路徑，或任何可解析為資料類型內欄位 (例如 STRUCT) 的路徑。
已展開的陣列。

`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 中，`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` 語法，但 `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 中沒有直接對應的函式：

BIT_XOR

窗型函式

下表列出常見 Amazon Redshift 窗口函式與 BigQuery 對應函式之間的對應關係。BigQuery 中的時間窗函式包括分析匯總函式、匯總函式、導覽函式和編號函式。

條件運算式

下表列出常見 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)，但不支援時區縮寫 (例如 PDT)。
`CONVERT_TIMEZONE( [source_timezone], target_timezone, timestamp )`	`PARSE_TIMESTAMP( "%c%z", FORMAT_TIMESTAMP( "%c%z", timestamp, target_timezone ) )` 注意：`source_timezone` 是 BigQuery 中的世界標準時間。
`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)` 的結果為 0。
`X ^ Y`	`POW(X, Y)` `POWER(X, Y)` 注意：與 Amazon Redshift 不同，BigQuery 中的 `^` 運算子會執行位元運算 xor。
`\| / 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 (位元運算 xor)

數學函式

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` 子句中參照其他資料表。您可以在 BigQuery 中使用 `WHERE` 子句中的子查詢來達成這項目標。

`MERGE` 陳述式

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

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

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

在 Amazon Redshift 中，您可以使用 DELETE 陳述式，然後再使用 INSERT 陳述式，覆寫目標資料表中的所有資料欄。DELETE 陳述式會移除應更新的資料列，然後 INSERT 陳述式會插入更新後的資料列。BigQuery 資料表的 DML 陳述式每日上限為 1,000 個，因此您應將 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 CREATE TABLE 陳述式都與 BigQuery 相容，但以下語法元素在 BigQuery 中並未使用：

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` 設定會指定用於節省處理時間和減少儲存空間。	您不需要使用或保留 `BACKUP NO` 表格選項，因為 BigQuery 會自動保留所有表格的最多 7 天的歷來版本，不會影響處理時間或帳單儲存空間。
`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)

使用者定義函式可讓您建立自訂作業的函式。這些函式會接受輸入資料欄、執行各項動作，並以值的形式傳回這些動作的結果。

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` (適用於 SQL UDF) 或 `plpythonu` (適用於 Python UDF)。	您不需要為 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 Data Editor 角色的使用者 (`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 中使用：

DECLARE cursor_name CURSOR [FOR] ...
PREPARE plan_name [ (datatype [, ...] ) ] AS statement
OPEN cursor_name FOR SELECT ...
FETCH [ NEXT | ALL | {FORWARD [ count | ALL ] } ] FROM cursor_name
CLOSE cursor_name;

如果您使用游標來傳回結果集，可以使用 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 statements END LOOP [ label ];`	`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