Amazon Redshift SQL 변환 가이드

이 문서에서는 마이그레이션을 계획하는 데 도움이 되도록 Amazon Redshift와 BigQuery 간 SQL 구문 유사점과 차이점을 자세히 설명합니다. 일괄 SQL 변환을 사용하여 SQL 스크립트를 일괄적으로 마이그레이션하거나 대화형 SQL 변환을 사용하여 임시 쿼리를 변환합니다.

이 가이드는 엔터프라이즈 아키텍트, 데이터베이스 관리자, 애플리케이션 개발자, IT 보안 전문가를 대상으로 합니다. 이 문서에서는 사용자가 Amazon Redshift에 익숙하다고 가정합니다.

데이터 유형

이 섹션에서는 Amazon Redshift와 BigQuery의 데이터 유형에서 유사점을 보여줍니다.

Amazon Redshift		BigQuery	참고
데이터 유형	별칭	데이터 유형
`SMALLINT`	`INT2`	`INT64`	Amazon Redshift의 `SMALLINT`는 2바이트이고 BigQuery의 `INT64`는 8바이트입니다.
`INTEGER`	`INT, INT4`	`INT64`	Amazon Redshift의 `INTEGER`는 4바이트이고 BigQuery의 `INT64`는 8바이트입니다.
`BIGINT`	`INT8`	`INT64`	Amazon Redshift의 `BIGINT` 및 BigQuery의 `INT64` 모두 8바이트입니다.
`DECIMAL`	`NUMERIC`	`NUMERIC`
`REAL`	`FLOAT4`	`FLOAT64`	Amazon Redshift의 `REAL`는 4바이트이고 BigQuery의 `FLOAT64`는 8바이트입니다.
`DOUBLE PRECISION`	`FLOAT8, FLOAT`	`FLOAT64`
`BOOLEAN`	`BOOL`	`BOOL`	Amazon Redshift의 `BOOLEAN`은 `TRUE`, `t`, `true`, `y`, `yes`, `1`를 true의 유효한 리터럴 값으로 사용할 수 있습니다. BigQuery의 `BOOL` 데이터 유형은 대소문자를 구분하지 않는 `TRUE`를 사용합니다.
`CHAR`	`CHARACTER, NCHAR, BPCHAR`	`STRING`
`VARCHAR`	`CHARACTER VARYING, NVARCHAR, TEXT`	`STRING`
`DATE`		`DATE`
`TIMESTAMP`	`TIMESTAMP WITHOUT TIME ZONE`	`DATETIME`
`TIMESTAMPTZ`	`TIMESTAMP WITH TIME ZONE`	`TIMESTAMP`	참고: BigQuery에서는 시간대를 사용해 타임스탬프를 파싱하거나 표시할 타임스탬프 형식을 지정합니다. 문자열 형식의 타임스탬프에 시간대가 포함될 수 있지만 BigQuery에서 문자열을 파싱할 때 타임스탬프를 해당 UTC 시간으로 저장합니다. 시간대가 명시적으로 지정되어 있지 않은 경우 기본 시간대인 UTC가 사용됩니다. 시간대 이름 또는 (-\|+)HH:MM을 사용하는 UTC로부터의 오프셋이 지원되지만 PDT와 같은 시간대 약어는 지원되지 않습니다.
`GEOMETRY`		`GEOGRAPHY`	지리 공간 데이터 쿼리를 지원합니다.

또한 BigQuery에는 직접적인 Amazon Redshift 아날로그가 없는 다음과 같은 데이터 유형도 있습니다.

암시적 변환 유형

BigQuery로 마이그레이션할 때는 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의 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` 절은 절이 `CROSS JOIN`이거나 조인된 테이블 중 하나가 데이터 유형 또는 배열 내의 필드인 경우를 제외하고 `JOIN` 조건이 필요합니다.

`WITH` 절

BigQuery WITH 절은 명명된 서브 쿼리를 한 개 이상 포함하며, 이는 후속 SELECT 문에서 참조할 때 실행됩니다. Amazon Redshift WITH 절은 BigQuery와 동일하게 작동하지만 절을 한 번 평가하고 결과를 재사용할 수 있습니다.

집합 연산자

Amazon Redshift 집합 연산자와 BigQuery 집합 연산자에는 약간의 차이점이 있습니다. 그러나 Amazon Redshift에서 실행 가능한 모든 집합 작업은 BigQuery에서 실행 가능합니다.

Amazon Redshift	BigQuery
`SELECT * FROM table1 UNION SELECT * FROM table2`	`SELECT * FROM table1 UNION DISTINCT SELECT * FROM table2` 참고: BigQuery와 Amazon Redshift 모두 `UNION ALL` 연산자를 지원합니다.
`SELECT * FROM table1 INTERSECT SELECT * FROM table2`	`SELECT * FROM table1 INTERSECT DISTINCT SELECT * FROM table2`
`SELECT * FROM table1 EXCEPT SELECT * FROM table2`	`SELECT * FROM table1 EXCEPT DISTINCT SELECT * FROM table2`
`SELECT * FROM table1 MINUS SELECT * FROM table2`	`SELECT * FROM table1 EXCEPT DISTINCT SELECT * FROM table2`
`SELECT * FROM table1 UNION SELECT * FROM table2 EXCEPT SELECT * FROM table3`	`SELECT * FROM table1 UNION ALL ( SELECT * FROM table2 EXCEPT SELECT * FROM table3 )` 참고: BigQuery에서는 서로 다른 집합 작업을 분리하려면 괄호로 묶어야 합니다. 동일한 집합 연산자가 반복되는 경우 괄호가 필요하지 않습니다.

`ORDER BY` 절

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와 관련된 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의 경우 이스케이프 문자 2개로 백슬래시 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_ADD(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 날짜 및 시간 함수에는 날짜 함수, datetime 함수, 시간 함수, 타임스탬프 함수가 포함됩니다.

Amazon Redshift와 BigQuery에서 동일하게 보이는 함수는 서로 다른 데이터 유형을 반환할 수 있습니다.

Amazon Redshift	BigQuery
`ADD_MONTHS( date, integer )`	`CAST( DATE_ADD( date, INTERVAL integer MONTH ) AS TIMESTAMP )`
timestamptz_or_timestamp `AT TIME ZONE timezone`	`PARSE_TIMESTAMP( "%c%z", FORMAT_TIMESTAMP( "%c%z", timestamptz_or_timestamp, timezone ) )` 참고: 시간대는 타임스탬프를 파싱하거나 표시할 타임스탬프 형식을 지정하는 데 사용됩니다. 문자열 형식의 타임스탬프에 시간대가 포함될 수 있지만 BigQuery에서 문자열을 파싱할 때 타임스탬프를 해당 UTC 시간으로 저장합니다. 시간대가 명시적으로 지정되어 있지 않은 경우 기본 시간대인 UTC가 사용됩니다. 시간대 이름 또는 UTC로부터의 오프셋(-HH:MM)이 지원되지만 시간대 약어(PDT 등)는 지원되지 않습니다.
`CONVERT_TIMEZONE( [source_timezone], target_timezone, timestamp )`	`PARSE_TIMESTAMP( "%c%z", FORMAT_TIMESTAMP( "%c%z", timestamp, target_timezone ) )` 참고: BigQuery에서는 `source_timezone`은 UTC입니다.
`CURRENT_DATE` 참고: 현재 세션 시간대(기본적으로 UTC)에서 현재 트랜잭션의 시작 날짜를 반환합니다.	`CURRENT_DATE()` 참고: 현재 문의 시작 날짜를 UTC 시간대로 반환됩니다.
`DATE_CMP(date1, date2)`	`CASE WHEN date1 = date2 THEN 0 WHEN date1 > date2 THEN 1 ELSE -1 END`
`DATE_CMP_TIMESTAMP(date1, date2)`	`CASE WHEN date1 = CAST(date2 AS DATE) THEN 0 WHEN date1 > CAST(date2 AS DATE) THEN 1 ELSE -1 END`
`DATE_CMP_TIMESTAMPTZ(date, timestamptz)`	`CASE WHEN date > DATE(timestamptz) THEN 1 WHEN date < DATE(timestamptz) THEN -1 ELSE 0 END`
`DATE_PART_YEAR(date)`	`EXTRACT(YEAR FROM date)`
`DATEADD(date_part, interval, date)`	`CAST( DATE_ADD( date, INTERVAL interval datepart ) AS TIMESTAMP )`
`DATEDIFF( date_part, date_expression1, date_expression2 )`	`DATE_DIFF( date_expression1, date_expression2, date_part )`
`DATE_PART(date_part, date)`	`EXTRACT(date_part FROM date)`
`DATE_TRUNC('date_part', timestamp)`	`TIMESTAMP_TRUNC(timestamp, date_part)`
`EXTRACT(date_part FROM timestamp)`	`EXTRACT(date_part FROM timestamp)`
`GETDATE()`	`PARSE_TIMESTAMP( "%c", FORMAT_TIMESTAMP( "%c", CURRENT_TIMESTAMP() ) )`
`INTERVAL_CMP( interval_literal1, interval_literal2 )`	Redshift 간격의 경우 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의 나누기는 정수가 아닌 값을 반환합니다. 나누기 연산의 오류(0으로 나누기 오류)를 방지하려면 `SAFE_DIVIDE(X, Y)` 또는 `IEEE_DIVIDE(X, Y)`를 사용하세요.
`X % Y`	`MOD(X, Y)` 참고: 나누기 연산의 오류를 방지하려면(0으로 나누기 오류) `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가 Cast 변환을 수행할 수 없는 경우 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는 서브 쿼리를 사용한 값 삽입(서브 쿼리를 사용하여 값 중 하나를 계산)도 지원하는데 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 문이 더 빠르고, 이후에 VACUUM 및 ANALYZE 작업이 필요하지 않기 때문에 정규화되지 않은 DELETE 문보다 권장됩니다. 하지만 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 작업은 각 대상 행에 대해 최대 1개의 소스 행과 일치해야 합니다.

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` 설정이 지정됩니다.	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에서 외부 테이블을 참조하려면 최근 바인딩 뷰가 필요합니다.	BigQuery에서 뷰를 만들려면 모든 참조 객체가 이미 존재해야 합니다. BigQuery에서는 외부 데이터 소스를 쿼리할 수 있습니다.

사용자 정의 함수(UDF)

UDF를 사용하면 커스텀 작업을 위한 함수를 만들 수 있습니다. 이러한 함수는 입력 열을 받아 작업을 수행하고 이러한 작업의 결과를 값으로 반환합니다.

Amazon Redshift와 BigQuery 모두 SQL 표현식을 사용한 UDF를 지원합니다. 또한 Amazon Redshift에서는 Python 기반 UDF를 만들 수 있고 BigQuery에서는 자바스크립트 기반 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 SQL type encodings in JavaScript 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 테스트 도구를 사용하여 함수를 테스트할 수도 있습니다.
언어	언어를 SQL UDF의 경우 `sql` 로 지정하거나 Python UDF의 경우 `plpythonu`로 지정하려면 `LANGUAGE` 리터럴을 사용해야 합니다.	SQL UDF에 `LANGUAGE` 를 지정할 필요가 없지만 언어를 자바스크립트 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 한도를 참조하세요.	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를 사용하면 4가지 SQL 표준 트랜잭션 격리 수준을 모두 지정할 수 있지만 모든 격리 수준을 직렬화 가능하도록 처리할 수 있습니다.

BigQuery는 트랜잭션도 지원합니다. BigQuery는 쿼리가 시작되기 전에 마지막으로 커밋된 데이터를 쿼리가 읽는 스냅샷 격리를 사용하여 최적의 동시 실행 제어(첫 번째 성공 커밋)를 실행할 수 있습니다. 이 접근 방법은 행 및 변형 기준으로 그리고 동일한 DML 문 내의 여러 행에서 동일한 수준의 일관성을 보장하고 교착 상태도 방지합니다. 동일한 테이블에 대해 여러 DML 업데이트가 있는 경우 BigQuery는 최악 동시 실행 제어로 전환됩니다. 로드 작업은 완전히 독립적으로 실행되고 테이블에 추가될 수 있습니다.

롤백

저장된 프러시저를 실행하는 동안 Amazon Redshift에서 오류가 발생하면 트랜잭션의 모든 변경사항을 롤백합니다. 또한 저장된 프로시저의 ROLLBACK 트랜잭션 제어 문을 사용하여 모든 변경사항을 삭제할 수 있습니다.

BigQuery에서는 ROLLBACK TRANSACTION 문을 사용할 수 있습니다.

데이터베이스 한도

BigQuery 공개 문서 에서 최신 할당량 및 한도를 확인하세요. 대규모 사용자를 위한 대량의 할당량은 Cloud 지원팀에 문의하여 늘릴 수 있습니다. 다음 표에서는 Amazon Redshift와 BigQuery 데이터베이스 한도를 비교합니다.

한도	Amazon Redshift	BigQuery
대형 및 초대형 클러스터 노드 유형의 각 데이터베이스 테이블	9,900	무제한
초대형 클러스터 노드 유형의 각 데이터베이스 테이블	20,000	무제한
각 클러스터에 만들 수 있는 사용자 정의 데이터베이스	60	무제한
최대 행 크기	4MB	100MB