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는 추가 테이블 참조도 지원합니다.

JOIN 유형

Amazon Redshift와 BigQuery 모두 다음 유형의 조인을 지원합니다.

아래 표에는 기타 다른 차이점 목록이 포함되어 있습니다.

Amazon Redshift BigQuery

SELECT col
FROM table1
NATURAL INNER JOIN
table2

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


참고: BigQuery에서 JOIN 절은 절이 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 절

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와 관련된 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에 직접 아날로그가 없습니다.

윈도우 함수

다음 표는 일반적인 Amazon Redshift 윈도우 함수와 그에 상응하는 BigQuery 함수 간의 매핑을 보여줍니다. BigQuery의 윈도우 함수에는 분석 집계 함수, 집계 함수, 탐색 함수, 번호 지정 함수가 포함됩니다.


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

조건식

다음 표는 일반적인 Amazon Redshift 조건부 표현식과 그에 해당하는 BigQuery 표현식 간의 매핑을 보여줍니다.

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

BigQuery는 다음과 같은 조건식도 제공합니다. 이 조건식은 Amazon Redshift에 직접 아날로그가 없습니다.

날짜 및 시간 함수

다음 표는 일반적인 Amazon Redshift 날짜 및 시간 함수와 그에 해당하는 BigQuery 함수 간의 매핑을 보여줍니다. BigQuery 날짜 및 시간 함수에는 날짜 함수, 날짜/시간 함수, 시간 함수, 타임스탬프 함수가 포함됩니다.

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

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

참고: 시간대는 타임스탬프를 파싱하거나 표시할 타임스탬프 형식을 지정하는 데 사용됩니다. 문자열 형식의 타임스탬프에 시간대가 포함될 수 있지만 BigQuery에서 문자열을 파싱할 때 타임스탬프를 해당 UTC 시간으로 저장합니다. 시간대가 명시적으로 지정되어 있지 않은 경우 기본 시간대인 UTC가 사용됩니다. 시간대 이름 또는 UTC로부터의 오프셋(-HH:MM)이 지원되지만 시간대 약어(PDT 등)는 지원되지 않습니다.
CONVERT_TIMEZONE(
[source_timezone],
target_timezone,
timestamp
)		 PARSE_TIMESTAMP(
"%c%z",
FORMAT_TIMESTAMP(
"%c%z",
timestamp,
target_timezone
)
)

참고: BigQuery에서는 source_timezone은 UTC입니다.
CURRENT_DATE

참고: 현재 세션 시간대(기본적으로 UTC)에서 현재 트랜잭션의 시작 날짜를 반환합니다. 		CURRENT_DATE()

참고: 현재 문의 시작 날짜를 UTC 시간대로 반환됩니다.
DATE_CMP(date1, date2) CASE
WHEN date1 = date2 THEN 0
WHEN date1 > date2 THEN 1
ELSE -1
END
DATE_CMP_TIMESTAMP(date1, date2) CASE
WHEN date1 = CAST(date2 AS DATE)
THEN 0
WHEN date1 > CAST(date2 AS DATE)
THEN 1
ELSE -1
END
DATE_CMP_TIMESTAMPTZ(date, timestamptz) CASE
WHEN date > DATE(timestamptz)
THEN 1
WHEN date < DATE(timestamptz)
THEN -1
ELSE 0
END
DATE_PART_YEAR(date) EXTRACT(YEAR FROM date)
DATEADD(date_part, interval, date) CAST(
DATE_ADD(
date,
INTERVAL interval datepart
)
AS TIMESTAMP
)
DATEDIFF(
date_part,
date_expression1,
date_expression2
) 		DATE_DIFF(
date_expression1,
date_expression2,
date_part
)
DATE_PART(date_part, date) EXTRACT(date_part FROM date)
DATE_TRUNC('date_part', timestamp) TIMESTAMP_TRUNC(timestamp, date_part)
EXTRACT(date_part FROM timestamp) EXTRACT(date_part FROM timestamp)
GETDATE() PARSE_TIMESTAMP(
"%c",
FORMAT_TIMESTAMP(
"%c",
CURRENT_TIMESTAMP()
)
)
INTERVAL_CMP(
interval_literal1,
interval_literal2
) 		Redshift 간격의 경우 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에 직접 아날로그가 없는 다음과 같은 수학 연산자도 제공합니다.

수학 함수

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에 사용되지 않습니다.

커서를 사용하여 결과 집합을 반환하는 경우 BigQuery에서 임시 테이블을 사용하여 비슷한 동작을 수행할 수 있습니다.

동적 SQL 문

BigQuery의 스크립팅 기능은 다음 표에 표시된 것처럼 동적 SQL 문을 지원합니다.

Amazon Redshift BigQuery
EXECUTE EXECUTE IMMEDIATE

제어 흐름 문

Amazon Redshift BigQuery
IF..THEN..ELSIF..THEN..ELSE..END IF IF condition
THEN stmts
ELSE stmts
END IF
name CURSOR [ ( arguments ) ] FOR query 커서 또는 세션은 BigQuery에서 사용되지 않습니다.
[< LOOP
sql_statement_list END LOOP;
WHILE condition LOOP stmts END LOOP WHILE condition
DO stmts
END WHILE
EXIT BREAK

일관성 보장 및 트랜잭션 격리

Amazon Redshift와 BigQuery는 모두 원자적인 특성이 있습니다. 즉, 여러 행에 걸쳐 변형당 수준에서 ACID와 호환됩니다.

트랜잭션

Amazon Redshift는 기본적으로 트랜잭션에 직렬화 가능한 격리를 지원합니다. Amazon Redshift를 사용하면 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