このページは 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 の有効なリテラル値として `TRUE`、`t`、`true`、`y`、`yes`、`1` を使用できます。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 に移行する際は、BigQuery によって暗黙的に変換される以下のデータ型を除き、Amazon Redshift の暗黙的変換のほとんどを 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 が暗黙的に変換しない Amazon Redshift データ型を、BigQuery のCAST(expression AS type) 関数、または　DATE と TIMESTAMP 変換関数のいずれかを使用して変換できます。

クエリを移行する際、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 でサポートされています。

BigQuery テーブルは、FROM 句で以下を使用することによって参照できます。

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

BigQuery はその他のテーブル参照もサポートしています。

FOR SYSTEM_TIME AS OF を使用したテーブル定義と行の履歴バージョン。
フィールドパス、またはデータ型（STRUCT など）の内部にあるフィールドに解決される任意のパス。
フラット化された配列。

`JOIN` 型

Amazon Redshift と BigQuery はともに、以下のタイプの JOIN をサポートしています。

[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 ステートメントから参照されたときに実行される 1 つ以上の名前付きサブクエリが含まれます。Amazon Redshift の WITH 句は、句を 1 回評価してその結果を再利用できる点を除き、BigQuery のものと同じように動作します。

集合演算子

Amazon Redshift の集合演算子と BigQuery の集合演算子の間には、小さな違いがいくつかあります。ただし、Amazon Redshift で有効なすべての set 演算子は、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 では、set 演算子どうしを区別するためにかっこが必要です。同じ set 演算子を繰り返すときは、かっこは不要です。

`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` カウントと組み合わせて使用する必要があります。カウントの `INT64` 値を最小限必要な順序付きの行に必ず設定してください。すべての結果行を不必要に並べ替えると、クエリ実行のパフォーマンスが低下します。

条件

次の表に、Amazon Redshift に固有で BigQuery の同等のものに変換する必要がある Amazon Redshift 条件、または述語を示します。

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 の場合、エスケープ文字として 2 つのバックスラッシュ（\\）を使用する必要があります。
`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 )`
タイムゾーン付きタイムスタンプまたはタイムスタンプ `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 ) )` 注: `source_timezone` は BigQuery では 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 の間隔では、1 年が 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 の `^` 演算子はビット 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` 注: 第 2 オペランド `Y` が第 1 オペランド `X` のビット長（たとえば `X` が INT64 型の場合は 64）以上である場合、この演算子は 0 または b'\x00' バイトシーケンスを返します。`Y` が負の数の場合、この演算子はエラーを返します。
`X >> Y`	`X >> Y` 注: 第 1 オペランド `X` を右方にシフトします。この演算子は、符号付きの型で符号ビット拡張を行いません（左側の空いたビットを 0 で埋めます）。第 2 オペランド `Y` が第 1 オペランド `X` のビット長（たとえば `X` が INT64 型の場合は 64）以上である場合、この演算子は 0 または b'\x00' バイトシーケンスを返します。`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 では、NULL が許容される列の 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 ではサブクエリ（値の 1 つがサブクエリを使用して計算される）を使用した値の挿入もサポートされますが、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 では、修飾された DELETE ステートメントよりも TRUNCATE ステートメントをおすすめします。それは、より高速で、後で 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 操作を組み合わせて 1 つの　upsert　ステートメントにし、複数の操作を自動的に実行することができます。MERGE オペレーションでは、ターゲット行ごとに最大で 1 つのソース行を対応させる必要があります。

Amazon Redshift では単独の MERGE コマンドがサポートされませんが、INSERT、UPDATE、および DELETE 操作を 1 つのトランザクションで実行することで、既存の行の置換による merge 操作を実行できます。

既存の行の置換による merge 操作

Amazon Redshift では、ターゲットテーブル内のすべての列の上書きを、DELETE ステートメント、INSERT ステートメントの順に使用して実行できます。更新対象の行が DELETE ステートメントによって削除され、その後、更新後の行が INSERT ステートメントによって挿入されます。BigQuery のテーブルでは、DML ステートメントの数が 1 日あたり 1,000 件に制限されているため、次の表に示されるように INSERT、UPDATE、DELETE ステートメントを 1 つの MERGE ステートメントに統合して最適化する必要があります。

Amazon Redshift	BigQuery
既存の行の置換による merge 操作の実行をご覧ください。 `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, ...` 注: すべての列を更新するには、すべての列をリストする必要があります。
列リストの指定による merge 操作の実行をご覧ください。 `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` の設定では、処理時間を節約し、ストレージ容量を減らすように指定されています。	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 で一時テーブルをエミュレートする方法は、いくつかあります。

データセット TTL: 短い有効期間（たとえば 1 時間）のデータセットを作成します。このデータセット内に作成されたすべてのテーブルは、データセットの有効期間を超えて持続することがないため、一時的なものになります。このデータセット内のすべてのテーブルは、名前の先頭に temp と付けることで、一時的なものであることを明示できます。
テーブル TTL: 次のような DDL ステートメントを使用して、テーブル固有の短い有効期間のテーブルを作成します。
```
CREATE TABLE
temp.name (col1, col2, ...)
OPTIONS (expiration_timestamp=TIMESTAMP_ADD(CURRENT_TIMESTAMP(),
INTERVAL 1 HOUR));
```

`CREATE VIEW` ステートメント

次の表に、CREATE VIEW ステートメントに関して Amazon Redshift と BigQuery で同等のものを示します。

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 で外部テーブルを参照するには、Late Binding View が必要です。	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 は複数のクエリで再利用できるのに対し、一時的な UDF は 1 つのクエリ内でのみ使用できます。関数の変動性は、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.*` を権限の 1 つとして持っている）すべてのユーザーは、指定されたデータセットの関数を作成したり削除したりできます。 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` と 1 行で使用します。
`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 では、4 つの標準的な SQL トランザクション分離レベルのいずれも指定できますが、すべての分離レベルがシリアル化可能として処理されます。

また、BigQuery はトランザクションをサポートしています。BigQuery では、スナップショット隔離を使用して、オプティミスティック同時実行制御（最初の commit が優先）が確実に実行されるようにします。この場合、クエリは、クエリが開始される前に最後に commit されたデータを読み取ります。この方法により、行ごと、ミューテーションごと、同じ DML ステートメント内の行全体で、同じレベルの整合性が保証され、デッドロックも回避されます。同じテーブルに対して複数の DML 更新を行う場合、BigQuery は悲観的同時実行制御に切り替わります。読み込みジョブは完全に独立して実行され、テーブルへの連結を実行できます。

ロールバック

Amazon Redshift でストアドプロシージャの実行中にエラーが発生した場合、トランザクションで行われたすべての変更をロールバックします。さらに、ストアドプロシージャ内で ROLLBACK トランザクション制御ステートメントを使用することにより、すべての変更を破棄できます。

BigQuery では、ROLLBACK TRANSACTION ステートメントを使用できます。

データベースに関する制限

最新の割り当てと上限については、必ず BigQuery の公開ドキュメントを確認してください。大量のユーザーに多数の割り当てを行う場合は、クラウドサポートチームに連絡して上限を引き上げることができます。次の表に、Amazon Redshift と BigQuery のデータベース制限の比較を示します。

上限	Amazon Redshift	BigQuery
large および xlarge クラスタノードタイプの各データベース内のテーブル数	9,900	制限なし
8xlarge クラスタノードタイプの各データベース内のテーブル数	20,000	制限なし
各クラスタで作成可能なユーザー定義データベースの数	60	制限なし
最大行数	4 MB	100 MB