Panduan terjemahan Amazon Redshift SQL

Dokumen ini menjelaskan persamaan dan perbedaan sintaksis SQL antara Amazon Redshift dan BigQuery untuk membantu Anda merencanakan migrasi. Gunakan terjemahan SQL batch untuk memigrasikan skrip SQL secara massal, atau terjemahan SQL interaktif untuk menerjemahkan kueri ad hoc.

Audiens yang dituju untuk panduan ini adalah arsitek perusahaan, administrator database, developer aplikasi, dan spesialis keamanan IT. Anda dianggap sudah familier dengan Amazon Redshift.

Jenis data

Bagian ini menunjukkan padanan antara jenis data di Amazon Redshift dan di BigQuery.

Amazon Redshift BigQuery Catatan
Data type Alias Data type
SMALLINT INT2 INT64 SMALLINT Amazon Redshift adalah 2 byte, sedangkan INT64 BigQuery adalah 8 byte.
INTEGER

INT, INT4

 INT64 INTEGER Amazon Redshift adalah 4 byte, sedangkan INT64 BigQuery adalah 8 byte.
BIGINT INT8 INT64 BIGINT Amazon Redshift dan INT64 BigQuery sama-sama berukuran 8 byte.
DECIMAL NUMERIC NUMERIC
REAL FLOAT4 FLOAT64 REAL Amazon Redshift adalah 4 byte, sedangkan FLOAT64 BigQuery adalah 8 byte.
DOUBLE PRECISION

FLOAT8, FLOAT

 FLOAT64
BOOLEAN BOOL BOOL BOOLEAN Amazon Redshift dapat menggunakan TRUE, t, true, y, yes, dan 1 sebagai nilai literal yang valid untuk true. Jenis data BOOL BigQuery menggunakan TRUE yang tidak peka huruf besar/kecil.
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 Catatan: Di BigQuery, zona waktu digunakan saat mengurai stempel waktu atau memformat stempel waktu untuk ditampilkan. Stempel waktu berformat string mungkin menyertakan zona waktu, tetapi saat BigQuery mengurai string, stempel waktu tersebut akan menyimpan stempel waktu dalam waktu UTC yang setara. Jika zona waktu tidak ditentukan secara eksplisit, zona waktu default, yakni UTC, akan digunakan. Nama zona waktu atau offset dari UTC yang menggunakan (-|+)HH:MM didukung, tetapi singkatan zona waktu seperti PDT tidak didukung.
GEOMETRY GEOGRAPHY Dukungan untuk membuat kueri data geospasial.

BigQuery juga memiliki jenis data berikut yang tidak memiliki analog Amazon Redshift langsung:

Jenis konversi implisit

Saat bermigrasi ke BigQuery, Anda harus mengonversi sebagian besar konversi implisit Amazon Redshift ke konversi eksplisit BigQuery kecuali untuk jenis data berikut, yang dikonversi oleh BigQuery secara implisit.

BigQuery melakukan konversi implisit untuk jenis data berikut:

Dari jenis BigQuery Ke jenis BigQuery

INT64

FLOAT64

INT64

NUMERIC

NUMERIC

FLOAT64

BigQuery juga melakukan konversi implisit untuk literal berikut:

Dari jenis BigQuery Ke jenis BigQuery
Literal STRING
(misalnya "2008-12-25")

DATE

Literal STRING
(misalnya "2008-12-25 15:30:00")

TIMESTAMP

Literal STRING
(misalnya "2008-12-25T07:30:00")

DATETIME

Literal STRING
(misalnya "15:30:00")

TIME

Jenis konversi eksplisit

Anda dapat mengonversi jenis data Amazon Redshift yang tidak dikonversi secara implisit oleh BigQuery menggunakan fungsi CAST(expression AS type) BigQuery atau salah satu fungsi konversi DATE dan TIMESTAMP.

Saat memigrasikan kueri, ubah kemunculan fungsi CONVERT(type, expression) Amazon Redshift (atau sintaksis ::) ke fungsi CAST(expression AS type) BigQuery, seperti yang ditunjukkan pada tabel di bagian Fungsi pemformatan jenis data.

Sintaksis kueri

Bagian ini membahas perbedaan sintaksis kueri antara Amazon Redshift dan BigQuery.

Pernyataan SELECT

Sebagian besar pernyataan SELECT Amazon Redshift kompatibel dengan BigQuery. Tabel berikut berisi daftar perbedaan kecil.

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

Catatan: Redshift mendukung pembuatan dan referensi alias dalam pernyataan SELECT yang sama.

SELECT
x/total AS probability,
ROUND(100 * (x/total), 1) AS pct
FROM raw_data

BigQuery juga mendukung ekspresi berikut dalam pernyataan SELECT, yang tidak memiliki padanan Amazon Redshift:

Klausa FROM.

Klausa FROM dalam kueri mencantumkan referensi tabel yang menjadi sumber pemilihan data. Di Amazon Redshift, referensi tabel yang mungkin digunakan mencakup tabel, tampilan, dan sub kueri. Semua referensi tabel ini didukung di BigQuery.

Tabel BigQuery dapat dirujuk dalam klausa FROM menggunakan hal berikut:

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

BigQuery juga mendukung referensi tabel tambahan:

Jenis JOIN

Amazon Redshift maupun BigQuery mendukung jenis join berikut:

  • [INNER] JOIN
  • LEFT [OUTER] JOIN
  • RIGHT [OUTER] JOIN
  • FULL [OUTER] JOIN
  • CROSS JOIN dan cross join koma implisit yang setara.

Tabel berikut berisi daftar perbedaan kecil.

Amazon Redshift BigQuery

SELECT col
FROM table1
NATURAL INNER JOIN
table2

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


Catatan: Di BigQuery, JOIN memerlukan kondisi JOIN kecuali jika klausa adalah CROSS JOIN atau salah satu tabel gabungan adalah kolom dalam suatu tipe data atau array.

Klausa WITH.

Klausa WITH BigQuery berisi satu atau beberapa subkueri bernama yang dijalankan saat pernyataan SELECT berikutnya mereferensikannya. Klausa WITH Amazon Redshift berperilaku sama seperti klausa BigQuery dengan pengecualian bahwa Anda dapat mengevaluasi klausa satu kali dan menggunakan kembali hasilnya.

Operator set

Ada beberapa perbedaan kecil antara operator set Amazon Redshift dan operator set BigQuery. Namun, semua operasi set yang dapat dilakukan di Amazon Redshift dapat direplikasi di BigQuery.

Amazon Redshift BigQuery

SELECT * FROM table1
UNION
SELECT * FROM table2

SELECT * FROM table1
UNION DISTINCT
SELECT * FROM table2

Catatan: BigQuery dan Amazon Redshift mendukung operator 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
)


Catatan: BigQuery memerlukan tanda kurung untuk memisahkan operasi set yang berbeda. Jika operator set yang sama diulang, tanda kurung tidak diperlukan.

Klausa ORDER BY

Ada beberapa perbedaan kecil antara klausa ORDER BY Amazon Redshift dan klausa ORDER BY BigQuery.

Amazon Redshift BigQuery
Di Amazon Redshift, NULL diberi peringkat terakhir secara default (urutan menaik). Di BigQuery, NULL diberi peringkat pertama secara default (urutan menaik).

SELECT *
FROM table
ORDER BY expression
LIMIT ALL

SELECT *
FROM table
ORDER BY expression



Catatan: BigQuery tidak menggunakan sintaksis LIMIT ALL, tetapi ORDER BY mengurutkan semua baris secara default, sehingga menghasilkan perilaku yang sama dengan klausa LIMIT ALL Amazon Redshift. Sebaiknya sertakan klausa LIMIT dengan setiap klausa ORDER BY. Mengurutkan semua baris hasil akan menurunkan performa eksekusi kueri secara tidak perlu.

SELECT *
FROM table
ORDER BY expression
OFFSET 10

SELECT *
FROM table
ORDER BY expression
LIMIT count OFFSET 10



Catatan: Di BigQuery, OFFSET harus digunakan bersama dengan jumlah LIMIT. Pastikan untuk menetapkan nilai INT64 jumlah ke jumlah baris minimum yang diperlukan. Mengurutkan semua baris hasil
akan menurunkan performa eksekusi kueri secara tidak perlu.

Kondisi

Tabel berikut menunjukkan kondisi Amazon Redshift, atau predikat, yang spesifik untuk Amazon Redshift dan harus dikonversi ke kondisi BigQuery yang setara.

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


Catatan: BigQuery tidak mendukung karakter escape kustom. Anda harus menggunakan dua garis miring terbalik \\ sebagai karakter escape untuk BigQuery.

expression [NOT] SIMILAR TO pattern

IF(
LENGTH(
REGEXP_REPLACE(
expression,
pattern,
''
) = 0,
True,
False
)


Catatan: Jika NOT ditentukan, gabungkan ekspresi IF di atas dalam ekspresi NOT seperti yang ditunjukkan di bawah ini:

NOT(
IF(
LENGTH(...
)

expression [!] ~ pattern

[NOT] REGEXP_CONTAINS(
expression,
regex
)

Fungsi

Bagian berikut mencantumkan fungsi Amazon Redshift dan fungsi BigQuery yang setara.

Fungsi agregat

Tabel berikut menunjukkan pemetaan antara agregat Amazon Redshift yang umum, analisis agregat, dan fungsi agregat perkiraan dengan BigQuery yang setara.

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()

Catatan: Tidak mencakup kasus penggunaan agregasi.
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 juga menawarkan fungsi agregat, analisis agregat, dan agregat perkiraan berikut, yang tidak memiliki analog langsung di Amazon Redshift:

Fungsi agregat bitwise

Tabel berikut menunjukkan pemetaan antara fungsi agregat bitwise Amazon Redshift umum dengan BigQuery yang setara.

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 juga menawarkan fungsi agregat bit-wise berikut, yang tidak memiliki analog langsung di Amazon Redshift:

Fungsi jendela

Tabel berikut menunjukkan pemetaan antara fungsi jendela Amazon Redshift umum dengan BigQuery yang setara. Fungsi windowing di BigQuery mencakup fungsi agregat analisis, fungsi agregat, fungsi navigasi, dan fungsi penomoran.


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]
)

Ekspresi bersyarat

Tabel berikut menunjukkan pemetaan antara ekspresi kondisional Amazon Redshift yang umum dengan BigQuery yang setara.

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 juga menawarkan ekspresi kondisional berikut, yang tidak memiliki analog langsung di Amazon Redshift:

Fungsi tanggal dan waktu

Tabel berikut menunjukkan pemetaan antara fungsi tanggal dan waktu Amazon Redshift yang umum dengan BigQuery yang setara. Fungsi tanggal dan waktu BigQuery mencakup fungsi tanggal, fungsi tanggal dan waktu, fungsi waktu, fungsi waktu, dan fungsi stempel waktu.

Perlu diingat bahwa fungsi yang tampak identik di Amazon Redshift dan BigQuery dapat menampilkan jenis data yang berbeda.

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
)
)

Catatan: Zona waktu digunakan saat mengurai stempel waktu atau memformat stempel waktu untuk ditampilkan. Stempel waktu berformat string mungkin menyertakan zona waktu, tetapi saat BigQuery mengurai string, stempel waktu tersebut akan menyimpan stempel waktu dalam waktu UTC yang setara. Jika zona waktu tidak ditentukan secara eksplisit, zona waktu default, yakni UTC, akan digunakan. Nama zona waktu atau offset dari UTC (-HH:MM) didukung, tetapi singkatan zona waktu (seperti PDT) tidak didukung.
CONVERT_TIMEZONE(
[source_timezone],
target_timezone,
timestamp
)		 PARSE_TIMESTAMP(
"%c%z",
FORMAT_TIMESTAMP(
"%c%z",
timestamp,
target_timezone
)
)

Catatan: source_timezone adalah UTC di BigQuery.
CURRENT_DATE

Catatan: Menampilkan tanggal mulai untuk transaksi saat ini dalam zona waktu sesi saat ini (UTC secara default). 		CURRENT_DATE()

Catatan: Menampilkan tanggal mulai untuk pernyataan saat ini dalam zona waktu 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
) 		Untuk interval dalam Redshift, ada 360 hari dalam setahun. Di BigQuery, Anda dapat menggunakan fungsi yang ditentukan pengguna (UDF) berikut untuk mengurai interval Redshift dan menerjemahkannya ke detik.

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
)));

Untuk membandingkan literal interval, lakukan:

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

Catatan: Menampilkan stempel waktu mulai untuk transaksi saat ini dalam zona waktu sesi saat ini (UTC secara default). 		CURRENT_TIMESTAMP()

Catatan: Menampilkan stempel waktu mulai untuk pernyataan saat ini dalam zona waktu 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
)

Catatan: Redshift membandingkan stempel waktu di zona waktu yang ditentukan sesi pengguna. Zona waktu sesi pengguna default adalah UTC. 		CASE
WHEN timestamp = timestamptz
THEN 0
WHEN timestamp > timestamptz
THEN 1
ELSE -1
END

Catatan: BigQuery membandingkan stempel waktu dalam zona waktu UTC.
TIMESTAMPTZ_CMP(
timestamptz1,
timestamptz2
)

Catatan: Redshift membandingkan stempel waktu di zona waktu yang ditentukan sesi pengguna. Zona waktu sesi pengguna default adalah UTC. 		CASE
WHEN timestamptz1 = timestamptz2
THEN 0
WHEN timestamptz1 > timestamptz2
THEN 1
ELSE -1
END

Catatan: BigQuery membandingkan stempel waktu dalam zona waktu UTC.
TIMESTAMPTZ_CMP_DATE(
timestamptz,
date
)

Catatan: Redshift membandingkan stempel waktu di zona waktu yang ditentukan sesi pengguna. Zona waktu sesi pengguna default adalah UTC. 		CASE
WHEN
EXTRACT(
DATE FROM timestamptz) = date
THEN 0
WHEN
EXTRACT(
DATE FROM timestamptz) > date
THEN 1
ELSE -1
END

Catatan: BigQuery membandingkan stempel waktu dalam zona waktu UTC.
TIMESTAMPTZ_CMP_TIMESTAMP(
timestamptz,
Timestamp
)

Catatan: Redshift membandingkan stempel waktu di zona waktu yang ditentukan sesi pengguna. Zona waktu sesi pengguna default adalah UTC. 		CASE
WHEN timestamp = timestamptz
THEN 0
WHEN timestamp > timestamptz
THEN 1
ELSE -1
END

Catatan: BigQuery membandingkan stempel waktu dalam zona waktu UTC.
TIMEZONE(
timezone,
Timestamptz_or_timestamp
) 		PARSE_TIMESTAMP(
"%c%z", FORMAT_TIMESTAMP(
"%c%z",
timestamptz_or_timestamp,
timezone
)
)

Catatan: Zona waktu digunakan saat mengurai stempel waktu atau memformat stempel waktu untuk ditampilkan. Stempel waktu berformat string mungkin menyertakan zona waktu, tetapi saat BigQuery mengurai string, stempel waktu tersebut akan menyimpan stempel waktu dalam waktu UTC yang setara. Jika zona waktu tidak ditentukan secara eksplisit, zona waktu default, yakni UTC, akan digunakan. Nama zona waktu atau offset dari UTC (-HH:MM) didukung, tetapi singkatan zona waktu (seperti PDT) tidak didukung.
TO_TIMESTAMP(timestamp, format) PARSE_TIMESTAMP(
format,
FORMAT_TIMESTAMP(
format,
timestamp
)
)

Catatan: BigQuery mengikuti kumpulan elemen format yang berbeda. Zona waktu digunakan saat mengurai stempel waktu atau memformat stempel waktu untuk ditampilkan. Stempel waktu berformat string mungkin menyertakan zona waktu, tetapi saat BigQuery mengurai string, stempel waktu tersebut akan menyimpan stempel waktu dalam waktu UTC yang setara. Jika zona waktu tidak ditentukan secara eksplisit, zona waktu default, yakni UTC, akan digunakan. Nama zona waktu atau offset dari UTC (-HH:MM) didukung dalam string format, tetapi singkatan zona waktu (seperti PDT) tidak didukung.
TRUNC(timestamp) CAST(timestamp AS DATE)

BigQuery juga menawarkan fungsi tanggal dan waktu berikut, yang tidak memiliki analog langsung di Amazon Redshift:

Operator matematis

Tabel berikut menunjukkan pemetaan antara operator matematis Amazon Redshift yang umum dengan BigQuery yang setara.

Amazon Redshift BigQuery

X + Y

X + Y

X - Y

X - Y

X * Y

X * Y

X / Y


Catatan: Jika operator
melakukan pembagian bilangan bulat (dengan kata lain, jika X dan Y adalah bilangan bulat), sebuah bilangan bulat akan ditampilkan. Jika operator melakukan pembagian non-bilangan bulat, non-bilangan bulat akan ditampilkan.		 Jika pembagian bilangan bulat:
CAST(FLOOR(X / Y) AS INT64)

Jika bukan pembagian bilangan bulat:

CAST(X / Y AS INT64)


Catatan: Pembagian di BigQuery menampilkan non-bilangan bulat.
Untuk mencegah error dari operasi pembagian (error pembagian dengan nol), gunakan SAFE_DIVIDE(X, Y) atau IEEE_DIVIDE(X, Y).

X % Y

MOD(X, Y)


Catatan: Untuk mencegah error dari operasi pembagian (error pembagian dengan nol), gunakan SAFE.MOD(X, Y). SAFE.MOD(X, 0) menghasilkan 0.

X ^ Y

POW(X, Y)

POWER(X, Y)


Catatan: Tidak seperti Amazon Redshift, operator ^ di BigQuery menjalankan Bitwise xor.

| / X

SQRT(X)


Catatan: Untuk mencegah error dari operasi akar kuadrat (input negatif), gunakan SAFE.SQRT(X). Input negatif dengan SAFE.SQRT(X) menghasilkan NULL.

|| / X

SIGN(X) * POWER(ABS(X), 1/3)


Catatan: POWER(X, Y) BigQuery menampilkan error jika X adalah nilai terbatas yang kurang dari 0 dan Y adalah nonbilangan bulat.

@ X

ABS(X)

X << Y

X << Y


Catatan: Operator ini menampilkan 0 atau urutan byte b'\x00' jika Y operand kedua lebih besar dari atau sama dengan panjang bit X operand pertama (misalnya, 64 jika X memiliki jenis INT64). Operator ini menampilkan error jika Y negatif.

X >> Y

X >> Y


Catatan: Menggeser X operand pertama ke kanan. Operator ini tidak melakukan ekstensi bit tanda dengan jenis bertanda (operator mengisi bit kosong di sebelah kiri dengan 0). Operator ini menampilkan 0 atau urutan byte
b'\x00' jika Y operand kedua lebih besar dari atau sama dengan panjang bit X operand pertama (misalnya, 64 jika X memiliki jenis INT64). Operator ini menampilkan error jika Y negatif.

X & Y

X & Y

X | Y

X | Y

~X

~X

BigQuery juga menawarkan operator matematis berikut, yang tidak memiliki analog langsung di Amazon Redshift:

Fungsi matematika

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])

Fungsi string

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)

Catatan: CONCAT(...) BigQuery mendukung
menyambungkan string dalam jumlah berapa pun.
CRC32 Fungsi kustom yang ditentukan pengguna
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
)
)

Jika position ditentukan:

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

Catatan: BigQuery menyediakan dukungan ekspresi reguler menggunakan library re2; lihat dokumentasi untuk sintaksis ekspresi regulernya.
REGEXP_INSTR(
source_string,
pattern
[,position
[,occurrence]] ) 		IFNULL( STRPOS(
source_string, REGEXP_EXTRACT(
source_string,
pattern)
),0)

Jika source_string ditentukan:

REGEXP_REPLACE(
source_string,

pattern,
replace_string
)

Jika position ditentukan:

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)

Jika occurrence ditentukan:

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)

Catatan: BigQuery menyediakan dukungan ekspresi reguler
menggunakan library re2; lihat
dokumentasi itu untuk sintaksis
ekspresi regulernya.
REGEXP_REPLACE( source_string,
pattern
[, replace_string [, position]]
) 		REGEXP_REPLACE(
source_string,
pattern,
""
)

Jika source_string ditentukan:

REGEXP_REPLACE(
source_string,

pattern, replace_string
)

Jika position ditentukan:

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
)

Jika position ditentukan:

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

)

Jika occurrence ditentukan:

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


pattern
)[SAFE_ORDINAL(occurrence)]

Catatan: BigQuery menyediakan dukungan ekspresi reguler menggunakan library re2; lihat dokumentasi itu untuk sintaksis ekspresi regulernya.
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 ) 		Dapat diimplementasikan menggunakan 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)

Fungsi pemformatan jenis data

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
)

Catatan: BigQuery dan Amazon Redshift berbeda dalam cara menentukan string format untuk timestamp_expression.
TO_CHAR(
numeric_expression,
format
)		 FORMAT(
format,
numeric_expression
)

Catatan: BigQuery dan Amazon Redshift berbeda dalam cara menentukan string format untuk timestamp_expression.
TO_DATE(date_string, format) PARSE_DATE(date_string, format)

Catatan: BigQuery dan Amazon Redshift berbeda dalam cara menentukan string format untuk date_string.
TO_NUMBER(string, format) CAST(
FORMAT(
format,
numeric_expression
) TO INT64
)

Catatan: BigQuery dan Amazon Redshift berbeda dalam cara menentukan string format numerik.

BigQuery juga mendukung SAFE_CAST(expression AS typename), yang menampilkan NULL jika BigQuery tidak dapat melakukan transmisi; misalnya, SAFE_CAST("apple" AS INT64) menampilkan NULL.

Sintaksis DML

Bagian ini membahas perbedaan sintaksis bahasa pengelolaan data antara Amazon Redshift dan BigQuery.

Pernyataan INSERT

Amazon Redshift menawarkan kata kunci DEFAULT yang dapat dikonfigurasi untuk kolom. Di BigQuery, nilai DEFAULT untuk kolom nullable adalah NULL, dan DEFAULT tidak didukung untuk kolom yang diperlukan. Sebagian besar pernyataan INSERT Amazon Redshift kompatibel dengan BigQuery. Tabel berikut menunjukkan pengecualian.

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 juga mendukung penyisipan nilai menggunakan subkueri (dengan salah satu nilai dihitung menggunakan subkueri), yang tidak didukung di Amazon Redshift. Misalnya:

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

Pernyataan COPY

Perintah COPY Amazon Redshift memuat data ke dalam tabel dari file data atau dari tabel Amazon DynamoDB. BigQuery tidak menggunakan perintah SQL COPY untuk memuat data, tetapi Anda dapat menggunakan salah satu dari beberapa alat dan opsi non-SQL untuk memuat data ke dalam tabel BigQuery. Anda juga dapat menggunakan sink pipeline data yang disediakan di Apache Spark atau Apache Beam untuk menulis data ke BigQuery.

Pernyataan UPDATE

Sebagian besar pernyataan UPDATE Amazon Redshift kompatibel dengan BigQuery. Tabel berikut menunjukkan pengecualian.

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

Catatan: Semua pernyataan UPDATE di BigQuery memerlukan kata kunci WHERE, yang diikuti dengan kondisi.
UPDATE table
SET column = DEFAULT [,...] [FROM ...]
[WHERE ...]		 UPDATE table
SET column = NULL [, ...]
[FROM ...]
WHERE ...

Catatan: Perintah UPDATE BigQuery tidak mendukung nilai DEFAULT.

Jika pernyataan UPDATE Amazon Redshift tidak menyertakan klausa WHERE, pernyataan UPDATE BigQuery harus dikondisikan WHERE TRUE.

Pernyataan DELETE dan TRUNCATE

Pernyataan DELETE dan TRUNCATE adalah cara untuk menghapus baris dari tabel tanpa memengaruhi skema atau indeks tabel.

Di Amazon Redshift, pernyataan TRUNCATE direkomendasikan daripada pernyataan DELETE yang tidak memenuhi syarat karena lebih cepat dan tidak memerlukan operasi VACUUM dan ANALYZE setelahnya. Namun, Anda dapat menggunakan pernyataan DELETE untuk mencapai efek yang sama.

Di BigQuery, pernyataan DELETE harus memiliki klausa WHERE. Untuk mengetahui informasi selengkapnya tentang DELETE di BigQuery, lihat contoh DELETE BigQuery dalam dokumentasi DML.

Amazon Redshift BigQuery
DELETE [FROM] table_name

TRUNCATE [TABLE] table_name		 DELETE FROM table_name
WHERE TRUE

Pernyataan DELETE BigQuery memerlukan klausa 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 )

Di Amazon Redshift, USING memungkinkan tabel tambahan untuk direferensikan dalam klausa WHERE. Hal ini dapat dilakukan di BigQuery menggunakan subkueri dalam klausa WHERE.

Pernyataan MERGE

Pernyataan MERGE dapat menggabungkan operasi INSERT, UPDATE, dan DELETE menjadi satu pernyataan upsert dan menjalankan operasi secara atomik. Operasi MERGE harus cocok dengan maksimal satu baris sumber untuk setiap baris target.

Amazon Redshift tidak mendukung satu perintah MERGE. Namun, operasi penggabungan dapat dilakukan di Amazon Redshift dengan melakukan operasi INSERT, UPDATE, dan DELETE dalam transaksi.

Menggabungkan operasi dengan mengganti baris yang ada

Di Amazon Redshift, penimpaan semua kolom dalam tabel target dapat dilakukan menggunakan pernyataan DELETE, lalu pernyataan INSERT. Pernyataan DELETE menghapus baris yang harus diperbarui, lalu pernyataan INSERT menyisipkan baris yang telah diperbarui. Tabel BigQuery dibatasi hingga 1.000 pernyataan DML per hari. Oleh karena itu, Anda harus menggabungkan pernyataan INSERT, UPDATE, dan DELETE ke dalam satu pernyataan MERGE seperti yang ditampilkan di tabel berikut.

Amazon Redshift BigQuery
Lihat Melakukan operasi penggabungan dengan mengganti baris yang ada.

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,
...

Catatan: Semua kolom harus tercantum jika semua kolom diperbarui.
Lihat Melakukan operasi penggabungan dengan menentukan daftar kolom.

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

Sintaksis DDL

Bagian ini membahas perbedaan dalam sintaksis bahasa definisi data antara Amazon Redshift dan BigQuery.

Pernyataan SELECT INTO

Di Amazon Redshift, pernyataan SELECT INTO dapat digunakan untuk menyisipkan hasil kueri ke dalam tabel baru, yang menggabungkan pembuatan dan penyisipan tabel.

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 menawarkan beberapa cara untuk mengemulasikan tabel sementara. Lihat bagian tabel sementara untuk informasi selengkapnya.

Pernyataan CREATE TABLE

Sebagian besar pernyataan CREATE TABLE Amazon Redshift kompatibel dengan BigQuery, kecuali untuk elemen sintaksis berikut, yang tidak digunakan di 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
)

Catatan: Batasan UNIQUE dan PRIMARY KEY bersifat informatif dan tidak diterapkan oleh sistem 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)]

Catatan: Batasan UNIQUE dan PRIMARY KEY bersifat informatif dan tidak diterapkan oleh sistem Amazon Redshift. 		CREATE TABLE table_name
(
col1 data_type1[,...]
)
PARTITION BY column_name
CLUSTER BY column_name [, ...]

Catatan: BigQuery tidak menggunakan batasan tabel UNIQUE, PRIMARY KEY, atau FOREIGN KEY. Untuk mencapai pengoptimalan serupa yang disediakan batasan ini selama eksekusi kueri, buat partisi dan cluster tabel BigQuery Anda. CLUSTER BY mendukung hingga 4 kolom.
CREATE TABLE table_name
LIKE original_table_name 		Lihat contoh ini untuk mempelajari cara menggunakan tabel INFORMATION_SCHEMA untuk menyalin nama kolom, jenis data, dan batasan NOT NULL ke tabel baru.
CREATE TABLE table_name
(
col1 data_type1
)
BACKUP NO

Catatan: Di Amazon Redshift, setelan BACKUP NO ditentukan untuk menghemat waktu pemrosesan dan mengurangi ruang penyimpanan.		 Opsi tabel BACKUP NO tidak digunakan atau diperlukan karena BigQuery secara otomatis menyimpan hingga 7 hari versi historis dari semua tabel Anda tanpa memengaruhi waktu pemrosesan atau penyimpanan yang ditagih.
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 mendukung pengelompokan, yang memungkinkan penyimpanan kunci dalam pengurutan.
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 juga mendukung pernyataan DDL CREATE OR REPLACE TABLE, yang menimpa tabel jika sudah ada.

Pernyataan CREATE TABLE BigQuery juga mendukung klausa berikut, yang tidak memiliki padanan di Amazon Redshift:

Untuk mengetahui informasi selengkapnya tentang CREATE TABLE di BigQuery, lihat contoh CREATE TABLE BigQuery dalam dokumentasi DML.

Tabel sementara

Amazon Redshift mendukung tabel sementara, yang hanya terlihat dalam sesi saat ini. Ada beberapa cara untuk mengemulasi tabel sementara di BigQuery:

  • TTL set data: Membuat set data yang memiliki time to live (TTL) singkat (misalnya, satu jam) sehingga tabel apa pun yang dibuat dalam set data tersebut bersifat sementara karena tidak akan bertahan lebih lama daripada time to live set data. Anda dapat memberikan awalan untuk semua nama tabel dalam set data ini dengan temp untuk menunjukkan dengan jelas bahwa tabel tersebut bersifat sementara.

  • Tabel TTL: Membuat tabel yang memiliki time to live (TTL) singkat khusus tabel menggunakan pernyataan DDL yang mirip dengan berikut ini:

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

Pernyataan CREATE VIEW

Tabel berikut menunjukkan padanan antara Amazon Redshift dan BigQuery untuk pernyataan CREATE VIEW.

Amazon Redshift BigQuery
CREATE VIEW view_name AS SELECT ...kode> 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 ...
Tidak didukung. CREATE VIEW IF NOT EXISTS c view_name
OPTIONS(view_option_list)
AS SELECT …

Membuat tampilan baru hanya jika tampilan tidak ada dalam set data yang ditentukan.
CREATE VIEW view_name
AS SELECT ...
WITH NO SCHEMA BINDING

Di Amazon Redshift, tampilan binding terlambat diperlukan untuk mereferensikan tabel eksternal.		 Di BigQuery, untuk membuat tampilan, semua objek yang direferensikan harus sudah ada.

BigQuery memungkinkan Anda menjalankan kueri terhadap sumber data eksternal.

Fungsi yang ditentukan pengguna (UDF)

UDF memungkinkan Anda membuat fungsi untuk operasi kustom. Fungsi ini menerima kolom input, melakukan tindakan, dan menampilkan hasil tindakan tersebut sebagai nilai.

Amazon Redshift maupun BigQuery mendukung UDF menggunakan ekspresi SQL. Selain itu, di Amazon Redshift, Anda dapat membuat UDF berbasis Python, dan di BigQuery Anda dapat membuat UDF berbasis JavaScript.

Lihat repositori GitHub utilitas Google Cloud BigQuery untuk library UDF BigQuery umum.

Sintaksis CREATE FUNCTION

Tabel berikut membahas perbedaan sintaksis pembuatan UDF SQL antara Amazon Redshift dan BigQuery.

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

Catatan: Di SQL UDF BigQuery, jenis data yang ditampilkan bersifat opsional. BigQuery menyimpulkan jenis hasil fungsi dari isi fungsi SQL saat kueri memanggil fungsi.
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

Catatan: Volatilitas fungsi bukanlah parameter yang dapat dikonfigurasi di BigQuery. Semua volatilitas UDF BigQuery setara dengan volatilitas IMMUTABLE Amazon Redshift (artinya, tidak melakukan pencarian database atau menggunakan informasi yang tidak langsung ada dalam daftar argumennya).
CREATE [OR REPLACE] FUNCTION
function_name
([sql_arg_name sql_arg_data_type[,..]]) RETURNS data_type
IMMUTABLE
AS $$
SELECT_clause
$$ LANGUAGE sql

Catatan: Amazon Redshift hanya mendukung klausa SQL SELECT sebagai definisi fungsi. Selain itu, klausa SELECT tidak boleh menyertakan klausa FROM, INTO, WHERE, GROUP BY, ORDER BY, dan LIMIT. 		CREATE [OR REPLACE] FUNCTION
function_name
([sql_arg_name sql_arg_data_type[,..]]) RETURNS data_type
AS sql_expression

Catatan: BigQuery mendukung ekspresi SQL apa pun sebagai definisi fungsi. Namun, mereferensikan tabel, tampilan, atau model tidak didukung.
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

Catatan: Literal bahasa tidak perlu ditentukan dalam UDF GoogleSQL. BigQuery menafsirkan ekspresi SQL secara default. Selain itu, kutipan dolar 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 ($$), untuk menunjukkan awal dan akhir pernyataan fungsi.

Untuk UDF SQL, Amazon Redshift hanya mendukung klausa SELECT SQL sebagai definisi fungsi. Selain itu, klausa SELECT tidak boleh menyertakan klausa FROM, INTO, WHERE, GROUP
BY, ORDER BY, dan LIMIT .

Untuk UDF Python, Anda dapat menulis program Python menggunakan Library Standar Python 2.7 atau mengimpor modul kustom Anda dengan membuatnya menggunakan perintah CREATE LIBRARY .		 Di BigQuery, Anda harus menyertakan kode JavaScript dalam tanda kutip. Lihat Aturan Kutipan untuk mengetahui informasi selengkapnya.

Untuk UDF SQL, Anda dapat menggunakan ekspresi SQL apa pun sebagai definisi fungsi. Namun, BigQuery tidak mendukung referensi tabel, tampilan, atau model.

Untuk UDF JavaScript, Anda dapat menyertakan library kode eksternal secara langsung menggunakan bagian OPTIONS . Anda juga dapat menggunakan alat pengujian UDF BigQuery untuk menguji fungsi.
Bahasa Anda harus menggunakan literal LANGUAGE untuk menentukan bahasa sebagai sql untuk UDF SQL atau plpythonu untuk UDF Python. Anda tidak perlu menentukan LANGUAGE untuk UDF SQL, tetapi harus menentukan bahasa sebagai js untuk UDF JavaScript.
Status Amazon Redshift tidak mendukung pembuatan temporary UDF.

Amazon Redshift menyediakan opsi untuk menentukan volatilitas fungsi menggunakan literal VOLATILE, STABLE, atau IMMUTABLE . Ini digunakan untuk pengoptimalan oleh pengoptimal kueri.		 BigQuery mendukung persistent UDF maupun temporary UDF. Anda dapat menggunakan kembali persistent UDF di beberapa kueri, sedangkan Anda hanya dapat menggunakan temporary UDF dalam satu kueri.

Volatilitas fungsi bukanlah parameter yang dapat dikonfigurasi di BigQuery. Semua volatilitas UDF BigQuery setara dengan volatilitas IMMUTABLE Amazon Redshift.
Keamanan dan hak istimewa Untuk membuat UDF, Anda harus memiliki izin penggunaan dalam bahasa untuk SQL atau plpythonu (Python). Secara default, USAGE ON LANGUAGE SQL diberikan ke PUBLIC, tetapi Anda harus secara eksplisit memberikan USAGE ON LANGUAGE PLPYTHONU kepada pengguna atau grup tertentu.
Selain itu, Anda harus menjadi superuser untuk menggantikan UDF.		 Pemberian izin eksplisit untuk membuat atau menghapus semua jenis UDF tidak diperlukan di BigQuery. Setiap pengguna yang diberi peran BigQuery Data Editor (memiliki bigquery.routines.* sebagai salah satu izin) dapat membuat atau menghapus fungsi untuk set data yang ditentukan.

BigQuery juga mendukung pembuatan peran khusus. Hal ini dapat dikelola menggunakan Cloud IAM.
Batas Lihat batas-batas UDF Python. Lihat batas-batas UDF.

Pernyataan SQL transaksi dan metadata

Amazon Redshift BigQuery
SELECT * FROM STL_ANALYZE WHERE name
= 'T';		 Tidak digunakan di BigQuery. Anda tidak perlu mengumpulkan statistik untuk meningkatkan performa kueri. Untuk mendapatkan informasi tentang distribusi data, Anda dapat menggunakan fungsi agregat perkiraan.
ANALYZE [[ table_name[(column_name
[, ...])]]		 Tidak digunakan di BigQuery.
LOCK TABLE table_name; Tidak digunakan di BigQuery.
BEGIN TRANSACTION; SELECT ...
END TRANSACTION;		 BigQuery menggunakan snapshot isolation. Untuk mengetahui detailnya, lihat Jaminan konsistensi.
EXPLAIN ... Tidak digunakan di BigQuery.

Fitur serupa adalah penjelasan rencana kueri di konsol Google Cloud BigQuery, dan di logging audit di Cloud Monitoring.
SELECT * FROM SVV_TABLE_INFO WHERE
table = 'T';		 SELECT * EXCEPT(is_typed) FROM
mydataset.INFORMATION_SCHEMA.TABLES;

Untuk mengetahui informasi selengkapnya, lihat Pengantar BigQuery INFORMATION_SCHEMA.
VACUUM [table_name] Tidak digunakan di BigQuery. Tabel BigQuery yang dikelompokkan diurutkan secara otomatis.

Pernyataan SQL multi-pernyataan dan multi-baris

Amazon Redshift maupun BigQuery mendukung transaksi (sesi) sehingga mendukung pernyataan yang dipisahkan dengan titik koma yang dijalankan bersama secara konsisten. Untuk informasi selengkapnya, lihat Transaksi multi-pernyataan.

Pernyataan SQL prosedural

Pernyataan CREATE PROCEDURE

Amazon Redshift BigQuery
CREATE or REPLACE PROCEDURE CREATE PROCEDURE jika nama diperlukan.

Jika tidak, gunakan inline dengan BEGIN atau dalam satu baris dengan CREATE TEMP FUNCTION.
CALL CALL

Deklarasi dan penetapan variabel

Amazon Redshift BigQuery
DECLARE DECLARE

Mendeklarasikan variabel dari jenis yang ditentukan.
SET SET

Menetapkan variabel agar memiliki nilai ekspresi yang diberikan, atau menetapkan beberapa variabel sekaligus berdasarkan hasil dari beberapa ekspresi.

Pengendali kondisi error

Di Amazon Redshift, error yang terjadi selama eksekusi prosedur tersimpan akan mengakhiri alur eksekusi, mengakhiri transaksi, dan me-roll back transaksi. Hasil ini terjadi karena subtransaksi tidak didukung. Dalam prosedur yang disimpan Amazon Redshift, satu-satunya handler_statement yang didukung adalah RAISE. Di BigQuery, penanganan error adalah fitur inti dari alur kontrol utama, mirip dengan yang disediakan oleh bahasa lain dengan blok 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;

Deklarasi dan operasi kursor

Karena BigQuery tidak mendukung kursor atau sesi, pernyataan berikut tidak digunakan di BigQuery:

Jika menggunakan kursor untuk menampilkan kumpulan hasil, Anda dapat mencapai perilaku serupa menggunakan tabel sementara di BigQuery.

Pernyataan SQL dinamis

Fitur pembuatan skrip di BigQuery mendukung pernyataan SQL dinamis seperti yang ditunjukkan dalam tabel berikut.

Amazon Redshift BigQuery
EXECUTE EXECUTE IMMEDIATE

Pernyataan flow-of-control

Amazon Redshift BigQuery
IF..THEN..ELSIF..THEN..ELSE..END IF IF condition
THEN stmts
ELSE stmts
END IF
name CURSOR [ ( arguments ) ] FOR query Kursor atau sesi tidak digunakan di BigQuery.
[< LOOP
sql_statement_list END LOOP;
WHILE condition LOOP stmts END LOOP WHILE condition
DO stmts
END WHILE
EXIT BREAK

Jaminan konsistensi dan transaction isolation

Amazon Redshift maupun BigQuery bersifat atomik—yaitu mematuhi ACID pada tingkat per mutasi di banyak baris.

Transaksi

Amazon Redshift mendukung isolasi yang dapat diserialisasi secara default untuk transaksi. Amazon Redshift memungkinkan Anda menentukan salah satu dari empat tingkat transaction isolation standar SQL, tetapi memproses semua tingkat isolasi sebagai dapat diserialisasi.

BigQuery juga mendukung transaksi. BigQuery membantu memastikan kontrol konkurensi optimis (yang pertama di-commit memiliki prioritas) dengan isolasi snapshot, di mana kueri membaca data yang terakhir di-commit sebelum kueri dimulai. Pendekatan ini menjamin tingkat konsistensi yang sama pada basis per baris, per-mutasi, dan di seluruh baris dalam pernyataan DML yang sama, namun menghindari deadlock. Dalam kasus beberapa update DML terhadap tabel yang sama, BigQuery akan beralih ke kontrol konkurensi pesimistis. Tugas pemuatan dapat berjalan sepenuhnya secara independen dan ditambahkan ke tabel.

Rollback

Jika Amazon Redshift mengalami error saat menjalankan prosedur tersimpan, Amazon Redshift akan me-roll back semua perubahan yang dilakukan dalam transaksi. Selain itu, Anda dapat menggunakan pernyataan kontrol transaksi ROLLBACK dalam prosedur tersimpan untuk menghapus semua perubahan.

Di BigQuery, Anda dapat menggunakan pernyataan ROLLBACK TRANSACTION.

Batas database

Baca dokumentasi publik BigQuery untuk mengetahui kuota dan batas terbaru. Banyak kuota untuk pengguna bervolume besar dapat ditingkatkan dengan menghubungi tim dukungan Cloud. Tabel berikut menunjukkan perbandingan batas database Amazon Redshift dan BigQuery.

Batas Amazon Redshift BigQuery
Tabel di setiap database untuk jenis node cluster besar dan xlarge 9.900 Tidak dibatasi
Tabel di setiap database untuk jenis node cluster berukuran 8xlarge 20.000 Tidak dibatasi
Database yang ditentukan pengguna yang dapat Anda buat untuk setiap cluster 60 Tidak dibatasi
Ukuran baris maksimum 4 MB 100 MB