Amazon Redshift-SQL-Übersetzungsleitfaden

In diesem Dokument werden die Gemeinsamkeiten und Unterschiede in der SQL-Syntax zwischen Amazon Redshift und BigQuery beschrieben, damit Sie die Migration planen können. Verwenden Sie die Batch-SQL-Übersetzung, um Ihre SQL-Skripts im Bulk zu migrieren, oder die interaktive SQL-Übersetzung, um Ad-hoc-Abfragen zu übersetzen.

Diese Anleitung richtet sich an Unternehmensarchitekten, Datenbankadministratoren, Anwendungsentwickler und IT-Sicherheitsexperten. Es wird davon ausgegangen, dass Sie mit Amazon Redshift vertraut sind.

Datentypen

In diesem Abschnitt werden die Entsprechungen zwischen den Datentypen in Amazon Redshift und BigQuery beschrieben.

Amazon Redshift BigQuery Hinweise
Datentyp Alias Datentyp
SMALLINT INT2 INT64 SMALLINT von Amazon Redshift beträgt 2 Byte, während INT64 von BigQuery 8 Byte beträgt.
INTEGER

INT, INT4

 INT64 INTEGER von Amazon Redshift beträgt 4 Byte, während INT64 von BigQuery 8 Byte beträgt.
BIGINT INT8 INT64 Sowohl BIGINT von Amazon Redshift als auch INT64 von BigQuery betragen 8 Byte.
DECIMAL NUMERIC NUMERIC
REAL FLOAT4 FLOAT64 REAL von Amazon Redshift beträgt 4 Byte, während FLOAT64 von BigQuery 8 Byte beträgt.
DOUBLE PRECISION

FLOAT8, FLOAT

 FLOAT64
BOOLEAN BOOL BOOL BOOLEAN von Amazon Redshift kann TRUE, t, true, y, yes und 1 als gültige Literalwerte für "true" verwenden. Beim Datentyp BOOL von BigQuery wird TRUE ohne Berücksichtigung der Groß-/Kleinschreibung verwendet.
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 Hinweis: In BigQuery werden Zeitzonen beim Parsen von Zeitstempeln oder zum Formatieren von Zeitstempeln für die Anzeige verwendet. Ein Zeitstempel im Stringformat kann eine Zeitzone enthalten. Wenn BigQuery jedoch den String parst, wird der Zeitstempel in der entsprechenden UTC-Zeit gespeichert. Wenn eine Zeitzone nicht explizit angegeben ist, wird die Standardzeitzone UTC verwendet. Zeitzonennamen oder Zeitversatz von UTC mit (-|+)HH:MM werden unterstützt, Zeitzonen-Abkürzungen wie PDT werden jedoch nicht unterstützt.
GEOMETRY GEOGRAPHY Unterstützung für die Abfrage von raumbezogenen Daten.

BigQuery verfügt auch über die folgenden Datentypen, die kein direktes Amazon Redshift-Analogon haben:

Implizite Konvertierungstypen

Bei der Migration zu BigQuery müssen Sie die meisten impliziten Amazon Redshift-Konvertierungen in die expliziten BigQuery-Konvertierungen konvertieren, mit Ausnahme der folgenden Datentypen, die BigQuery implizit konvertiert.

BigQuery führt implizite Konvertierungen für die folgenden Datentypen durch:

Von BigQuery-Typ Zu BigQuery-Typ

INT64

FLOAT64

INT64

NUMERIC

NUMERIC

FLOAT64

BigQuery führt auch implizite Konvertierungen für die folgenden Literale durch:

Von BigQuery-Typ Zu BigQuery-Typ
STRING-Literal
(z. B. "2008-12-25")

DATE

STRING-Literal
(z. B. "2008-12-25 15:30:00")

TIMESTAMP

STRING-Literal
(z. B. "2008-12-25T07:30:00")

DATETIME

STRING-Literal
(z. B. "15:30:00")

TIME

Explizite Konvertierungstypen

Sie können Amazon Redshift-Datentypen konvertieren, die BigQuery nicht implizit mit der CAST(expression AS type)-Funktion von BigQuery oder einer der DATE- und TIMESTAMP-Konvertierungsfunktionen konvertiert.

Ändern Sie bei der Migration Ihrer Abfragen alle Vorkommen der Amazon Redshift-CONVERT(type, expression)-Funktion (oder die Syntax ::) in die BigQuery-CAST(expression AS type)-Funktion, wie in der Tabelle im Abschnitt zu Datentyp-Formatierungsfunktionen gezeigt.

Abfragesyntax

In diesem Abschnitt werden Unterschiede in der Abfragesyntax zwischen Amazon Redshift und BigQuery behandelt.

SELECT-Anweisung

Die meisten Amazon Redshift-SELECT-Anweisungen sind mit BigQuery kompatibel. Die folgende Tabelle enthält eine Liste mit geringfügigen Unterschieden.

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

Hinweis: Redshift unterstützt das Erstellen und Referenzieren eines Alias in derselben SELECT-Anweisung.

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

BigQuery unterstützt auch die folgenden Ausdrücke in SELECT-Anweisungen, die kein Amazon Redshift-Äquivalent haben:

FROM-Klausel

Eine FROM-Klausel in einer Abfrage listet die Tabellenreferenzen auf, aus denen Daten ausgewählt werden. In Amazon Redshift können Tabellenreferenzen Tabellen, Ansichten und Unterabfragen sein. Alle diese Tabellenreferenzen werden in BigQuery unterstützt.

Auf BigQuery-Tabellen kann in der FROM-Klausel mit Folgendem verwiesen werden:

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

BigQuery unterstützt auch zusätzliche Tabellenreferenzen:

JOIN-Typen

Sowohl Amazon Redshift als auch BigQuery unterstützen die folgenden Join-Typen:

Die folgende Tabelle enthält eine Liste mit geringfügigen Unterschieden.

Amazon Redshift BigQuery

SELECT col
FROM table1
NATURAL INNER JOIN
table2

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


Hinweis: In BigQuery erfordern JOIN-Klauseln eine JOIN-Bedingung, es sei denn, die Klausel ist einCROSS JOIN oder eine der verknüpften Tabellen ist ein Feld innerhalb eines Datentyps oder eines Arrays.

WITH-Klausel

Eine BigQuery-WITH-Klausel enthält eine oder mehrere Unterabfragen, die ausgeführt werden, wenn eine nachfolgende SELECT-Anweisung auf sie verweist. Amazon Redshift-Klauseln vom Typ WITH verhalten sich wie BigQuery, mit der Ausnahme, dass Sie die Klausel einmal auswerten und die Ergebnisse wiederverwenden können.

Set-Operatoren

Es gibt einige geringfügige Unterschiede zwischen Amazon Redshift-Set-Operatoren und BigQuery-Set-Operatoren. Alle Set-Vorgänge, die in Amazon Redshift möglich sind, können jedoch in BigQuery repliziert werden.

Amazon Redshift BigQuery

SELECT * FROM table1
UNION
SELECT * FROM table2

SELECT * FROM table1
UNION DISTINCT
SELECT * FROM table2

Hinweis: Sowohl BigQuery als auch Amazon Redshift unterstützen den 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
)


Hinweis: BigQuery benötigt Klammern, um verschiedene Set-Vorgänge zu trennen. Wenn derselbe Set-Operator wiederholt wird, sind keine Klammern erforderlich.

ORDER BY-Klausel

Es gibt einige kleinere Unterschiede zwischen Amazon Redshift ORDER BY -Klauseln and BigQuery ORDER BY -Klauseln.

Amazon Redshift BigQuery
In Amazon Redshift werden NULLs standardmäßig am niedrigsten eingestuft (aufsteigende Reihenfolge). In BigQuery werden NULLs standardmäßig am höchsten eingestuft (aufsteigende Reihenfolge).

SELECT *
FROM table
ORDER BY expression
LIMIT ALL

SELECT *
FROM table
ORDER BY expression



Hinweis: BigQuery verwendet nicht die Syntax LIMIT ALL, aber ORDER BY sortiert standardmäßig alle Zeilen, was dasselbe Verhalten wie bei der LIMIT ALL-Klausel von Amazon Redshift bewirkt. Es wird dringend empfohlen, in jede ORDER BY-Klausel eine LIMIT-Klausel aufzunehmen. Das Sortieren aller Ergebniszeilen verschlechtert die Abfrageausführungsleistung unnötig.

SELECT *
FROM table
ORDER BY expression
OFFSET 10

SELECT *
FROM table
ORDER BY expression
LIMIT count OFFSET 10



Hinweis: In BigQuery muss OFFSET zusammen mit einem LIMIT count verwendet werden. Achten Sie darauf, dass der Wert für count INT64 auf die mindestens erforderlichen geordneten Zeilen festgelegt wird. Das Sortieren aller Ergebniszeilen verschlechtert die Abfrageausführungsleistung unnötig.

Bedingungen

Die folgende Tabelle zeigt Amazon Redshift-Bedingungen, oder Prädikate, die für Amazon Redshift spezifisch sind und in ihr BigQuery-Äquivalent konvertiert werden müssen.

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


Hinweis: BigQuery unterstützt keine benutzerdefinierten Escape-Zeichen. Sie müssen für BigQuery zwei umgekehrte Schrägstriche (\\) als Escape-Zeichen verwenden.

expression [NOT] SIMILAR TO pattern

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


Hinweis: Wenn NOT angegeben ist, setzen Sie den obigen IF-Ausdruck wie unten dargestellt in einem NOT-Ausdruck um:

NOT(
IF(
LENGTH(...
)

expression [!] ~ pattern

[NOT] REGEXP_CONTAINS(
expression,
regex
)

Funktionen

In den folgenden Abschnitten werden die Amazon Redshift-Funktionen und ihre BigQuery-Entsprechungen aufgeführt.

Aggregatfunktionen

Die folgende Tabelle zeigt Zuordnungen zwischen gängigen Amazon Redshift-Aggregat-, Aggregatanalyse- und ungefähren Aggregatfunktionen mit ihren BigQuery-Entsprechungen.

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

Hinweis: Es werden keine Aggregationsanwendungsfälle behandelt.
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 bietet auch die folgenden Aggregat-, Aggregatanalyse- und ungefähren Aggregatfunktionen, die kein direktes Äquivalent in Amazon Redshift haben:

Bitweise Aggregatfunktionen

Die folgende Tabelle zeigt Zuordnungen zwischen gängigen bitweisen Amazon Redshift-Aggregatfunktionen mit ihren BigQuery-Entsprechungen.

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 bietet außerdem die folgende bitweise Aggregatfunktion, die in Amazon Redshift keine direkte Entsprechung hat:

Fensterfunktionen

Die folgende Tabelle zeigt Zuordnungen zwischen gängigen Amazon Redshift-Fensterfunktionen und ihren BigQuery-Entsprechungen. Zu den Fensterfunktionen in BigQuery gehören analytische Aggregatfunktionen, Aggregatfunktionen, Navigationsfunktionen und Nummerierungsfunktionen.


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

Bedingte Ausdrücke

Die folgende Tabelle zeigt Zuordnungen zwischen gängigen bedingten Amazon Redshift-Ausdrücken und ihren BigQuery-Entsprechungen.

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 bietet auch die folgenden bedingten Ausdrücke, die in Amazon Redshift keine direkte Entsprechung haben:

Funktionen für Datum und Uhrzeit

Die folgende Tabelle zeigt Zuordnungen zwischen gängigen Amazon Redshift-Datums- und -Uhrzeitfunktionen mit ihren BigQuery-Entsprechungen. BigQuery-Datums- und -Uhrzeitfunktionen umfassen Datumsfunktionen, datetimefunktionen, Uhrzeitfunktionen und Zeitstempelfunktionen.

Beachten Sie, dass Funktionen, die in Amazon Redshift und BigQuery identisch erscheinen, unterschiedliche Datentypen zurückgeben können.

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

Hinweis: Zeitzonen werden beim Parsen von Zeitstempeln oder zum Formatieren von Zeitstempeln für die Anzeige verwendet. Ein Zeitstempel im Stringformat kann eine Zeitzone enthalten. Wenn BigQuery jedoch den String parst, wird der Zeitstempel in der entsprechenden UTC-Zeit gespeichert. Wenn eine Zeitzone nicht explizit angegeben ist, wird die Standardzeitzone UTC verwendet. Zeitzonennamen oder der Zeitversatz von UTC mit (-|+)HH:MM werden unterstützt, Zeitzonen-Abkürzungen wie PDT werden jedoch nicht unterstützt.
CONVERT_TIMEZONE(
[source_timezone],
target_timezone,
timestamp
)		 PARSE_TIMESTAMP(
"%c%z",
FORMAT_TIMESTAMP(
"%c%z",
timestamp,
target_timezone
)
)

Hinweis: source_timezone ist in BigQuery UTC.
CURRENT_DATE

Hinweis: Gibt das Startdatum für die aktuelle Transaktion in der Zeitzone der aktuellen Sitzung zurück (standardmäßig UTC). 		CURRENT_DATE()

Hinweis: Gibt das Startdatum für die aktuelle Anweisung in der Zeitzone UTC zurück.
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
) 		Für Intervalle in Redshift gibt es 360 Tage im Jahr. In BigQuery können Sie die folgende benutzerdefinierte Funktion (UDF) verwenden, um ein Redshift-Intervall zu parsen und in Sekunden zu übersetzen.

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

Führen Sie zum Vergleichen von Intervallliteralen Folgendes aus:

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

Hinweis: Gibt den Startzeitstempel für die aktuelle Transaktion in der Zeitzone der aktuellen Sitzung zurück (standardmäßig UTC). 		CURRENT_TIMESTAMP()

Hinweis: Gibt den Startzeitstempel für die aktuelle Anweisung in der Zeitzone UTC zurück.
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
)

Hinweis: Redshift vergleicht Zeitstempel in der durch die Nutzersitzung definierten Zeitzone. Die Standardzeitzone der Nutzersitzung ist UTC. 		CASE
WHEN timestamp = timestamptz
THEN 0
WHEN timestamp > timestamptz
THEN 1
ELSE -1
END

Hinweis: BigQuery vergleicht Zeitstempel in der UTC-Zeitzone.
TIMESTAMPTZ_CMP(
timestamptz1,
timestamptz2
)

Hinweis: Redshift vergleicht Zeitstempel in der durch die Nutzersitzung definierten Zeitzone. Die Standardzeitzone der Nutzersitzung ist UTC. 		CASE
WHEN timestamptz1 = timestamptz2
THEN 0
WHEN timestamptz1 > timestamptz2
THEN 1
ELSE -1
END

Hinweis: BigQuery vergleicht Zeitstempel in der UTC-Zeitzone.
TIMESTAMPTZ_CMP_DATE(
timestamptz,
date
)

Hinweis: Redshift vergleicht Zeitstempel in der durch die Nutzersitzung definierten Zeitzone. Die Standardzeitzone der Nutzersitzung ist UTC. 		CASE
WHEN
EXTRACT(
DATE FROM timestamptz) = date
THEN 0
WHEN
EXTRACT(
DATE FROM timestamptz) > date
THEN 1
ELSE -1
END

Hinweis: BigQuery vergleicht Zeitstempel in der UTC-Zeitzone.
TIMESTAMPTZ_CMP_TIMESTAMP(
timestamptz,
Timestamp
)

Hinweis: Redshift vergleicht Zeitstempel in der durch die Nutzersitzung definierten Zeitzone. Die Standardzeitzone der Nutzersitzung ist UTC. 		CASE
WHEN timestamp = timestamptz
THEN 0
WHEN timestamp > timestamptz
THEN 1
ELSE -1
END

Hinweis: BigQuery vergleicht Zeitstempel in der UTC-Zeitzone.
TIMEZONE(
timezone,
Timestamptz_or_timestamp
) 		PARSE_TIMESTAMP(
"%c%z", FORMAT_TIMESTAMP(
"%c%z",
timestamptz_or_timestamp,
timezone
)
)

Hinweis: Zeitzonen werden beim Parsen von Zeitstempeln oder zum Formatieren von Zeitstempeln für die Anzeige verwendet. Ein Zeitstempel im Stringformat kann eine Zeitzone enthalten. Wenn BigQuery jedoch den String parst, wird der Zeitstempel in der entsprechenden UTC-Zeit gespeichert. Wenn eine Zeitzone nicht explizit angegeben ist, wird die Standardzeitzone UTC verwendet. Zeitzonennamen oder der Zeitversatz von UTC mit (-|+)HH:MM werden unterstützt, Zeitzonen-Abkürzungen wie PDT werden jedoch nicht unterstützt.
TO_TIMESTAMP(timestamp, format) PARSE_TIMESTAMP(
format,
FORMAT_TIMESTAMP(
format,
timestamp
)
)

Hinweis: BigQuery folgt einer anderen Gruppe von Formatelementen. Zeitzonen werden beim Parsen von Zeitstempeln oder zum Formatieren von Zeitstempeln für die Anzeige verwendet. Ein Zeitstempel im Stringformat kann eine Zeitzone enthalten. Wenn BigQuery jedoch den String parst, wird der Zeitstempel in der entsprechenden UTC-Zeit gespeichert. Wenn eine Zeitzone nicht explizit angegeben ist, wird die Standardzeitzone UTC verwendet. Zeitzonennamen oder Versatz von UTC (-HH:MM) werden im Formatstring unterstützt, Zeitzonen-Abkürzungen (z. B. PDT) werden jedoch nicht unterstützt.
TRUNC(timestamp) CAST(timestamp AS DATE)

BigQuery bietet außerdem die folgenden Datums- und Uhrzeitfunktionen, die in Amazon Redshift keine direkte Entsprechung haben:

Mathematische Operatoren

Die folgende Tabelle zeigt Zuordnungen zwischen gängigen mathematischen Operatoren von Amazon Redshift und ihren BigQuery-Entsprechungen.

Amazon Redshift BigQuery

X + Y

X + Y

X - Y

X - Y

X * Y

X * Y

X / Y


Hinweis: Wenn der Operator eine Ganzzahldivision
ausführt (mit anderen Worten, wenn X und Y beide Ganzzahlen sind), wird eine Ganzzahl zurückgegeben. Wenn der Operator eine Division mit Nicht-Ganzzahl durchführt, wird eine Nicht-Ganzzahl zurückgegeben.		 Bei Ganzzahldivision:
CAST(FLOOR(X / Y) AS INT64)

Bei Nicht-Ganzzahldivision:

CAST(X / Y AS INT64)


Hinweis: Die Division in BigQuery gibt eine nicht ganze Zahl zurück.
Verwenden Sie SAFE_DIVIDE(X, Y) oder IEEE_DIVIDE(X, Y), um Fehler bei einer Division zu vermeiden (Fehler bei Division durch 0).

X % Y

MOD(X, Y)


Hinweis: Verwenden Sie SAFE.MOD(X, Y), um Fehler bei einer Division zu vermeiden (Fehler bei Division durch 0). SAFE.MOD(X, 0) ergibt 0.

X ^ Y

POW(X, Y)

POWER(X, Y)


Hinweis: Im Unterschied zu Amazon Redshift führt der Operator ^ in BigQuery ein bitweises XOR aus.

| / X

SQRT(X)


Hinweis: Um Fehler bei einer Quadratwurzeloperation (negative Eingabe) zu vermeiden, verwenden Sie SAFE.SQRT(X). Eine negative Eingabe mit SAFE.SQRT(X) führt zu NULL.

|| / X

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


Hinweis: POWER(X, Y) von BigQuery gibt einen Fehler zurück, wenn X ein endlicher Wert kleiner als 0 und Y keine ganze Zahl ist.

@ X

ABS(X)

X << Y

X << Y


Hinweis: Dieser Operator gibt 0 oder die Bytesequenz b'\x00' zurück, wenn der zweite Operand Y größer oder gleich der Bitlänge des ersten Operanden X ist (z. B. 64, wenn X den Typ INT64 hat). Dieser Operator gibt einen Fehler aus, wenn Y negativ ist.

X >> Y

X >> Y


Hinweis: Verschiebt den ersten Operanden X nach rechts. Dieser Operator führt keine Vorzeichenbit-Erweiterung bei einem Typ mit Vorzeichen durch (er füllt freie Bits auf der linken Seite mit 0). Dieser Operator gibt 0 oder die Bytesequenz b'\x00'
zurück, wenn der zweite Operand Y größer oder gleich der Bitlänge des ersten Operanden X ist (z. B. 64, wenn X den Typ INT64 hat). Dieser Operator gibt einen Fehler aus, wenn Y negativ ist.

X & Y

X & Y

X | Y

X | Y

~X

~X

BigQuery bietet außerdem den folgenden mathematischen Operator, der in Amazon Redshift kein direktes Analogon hat:

Mathematische Funktionen:

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

Stringfunktionen

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)

Hinweis: CONCAT(...) in BigQuery unterstützt
die Verkettung einer beliebigen Anzahl von Strings.
CRC32 Benutzerdefinierte Funktion
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
)
)

Wenn position angegeben ist:

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

Hinweis: BigQuery unterstützt reguläre Ausdrücke mithilfe der re2-Bibliothek. Weitere Informationen zur entsprechenden Syntax regulärer Ausdrücke finden Sie in der zugehörigen Dokumentation.
REGEXP_INSTR(
source_string,
pattern
[,position
[,occurrence]] ) 		IFNULL( STRPOS(
source_string, REGEXP_EXTRACT(
source_string,
pattern)
),0)

Wenn source_string angegeben ist:

REGEXP_REPLACE(
source_string,

pattern,
replace_string
)

Wenn position angegeben ist:

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)

Wenn occurrence angegeben ist:

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)

Hinweis: BigQuery unterstützt reguläre Ausdrücke
mithilfe der re2-Bibliothek. Weitere
Informationen zur entsprechenden Syntax regulärer
Ausdrücke finden Sie in der zugehörigen Dokumentation.
REGEXP_REPLACE( source_string,
pattern
[, replace_string [, position]]
) 		REGEXP_REPLACE(
source_string,
pattern,
""
)

Wenn source_string angegeben ist:

REGEXP_REPLACE(
source_string,

pattern, replace_string
)

Wenn position angegeben ist:

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
)

Wenn position angegeben ist:

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

)

Wenn occurrence angegeben ist:

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


pattern
)[SAFE_ORDINAL(occurrence)]

Hinweis: BigQuery unterstützt reguläre Ausdrücke mithilfe der re2-Bibliothek. Weitere Informationen zur entsprechenden Syntax regulärer Ausdrücke finden Sie in der zugehörigen Dokumentation.
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 ) 		Kann mit UDFs implementiert werden:

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)

Datentyp-Formatierungsfunktionen

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
)

Hinweis: BigQuery und Amazon Redshift unterscheiden sich in der Angabe eines Formatstrings für timestamp_expression.
TO_CHAR(
numeric_expression,
format
)		 FORMAT(
format,
numeric_expression
)

Hinweis: BigQuery und Amazon Redshift unterscheiden sich in der Angabe eines Formatstrings für timestamp_expression.
TO_DATE(date_string, format) PARSE_DATE(date_string, format)

Hinweis: BigQuery und Amazon Redshift unterscheiden sich in der Angabe eines Formatstrings für date_string.
TO_NUMBER(string, format) CAST(
FORMAT(
format,
numeric_expression
) TO INT64
)

Hinweis: BigQuery und Amazon Redshift unterscheiden sich in der Angabe eines Strings im numerischen Format.

BigQuery unterstützt auch SAFE_CAST(expression AS typename), das NULL zurückgibt, wenn BigQuery keine Umwandlung durchführen kann. Beispielsweise gibt SAFE_CAST("apple" AS INT64) den Wert NULL zurück.

DML-Syntax

In diesem Abschnitt werden Unterschiede in der Syntax der Datenverwaltungssprache zwischen Amazon Redshift und BigQuery behandelt.

INSERT-Anweisung

Amazon Redshift bietet ein konfigurierbares DEFAULT-Schlüsselwort für Spalten. In BigQuery lautet der DEFAULT-Wert für Spalten mit zulässigen Nullwerten NULL und DEFAULT wird für die erforderlichen Spalten nicht unterstützt. Die meisten Amazon Redshift-INSERT-Anweisungen sind mit BigQuery kompatibel. Die folgende Tabelle enthält Ausnahmen.

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 unterstützt auch das Einfügen von Werten mithilfe einer Unterabfrage (wobei einer der Werte mithilfe einer Unterabfrage berechnet wird), was in Amazon Redshift nicht unterstützt wird. Beispiel:

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

COPY-Anweisung

Der Befehl COPY von Amazon Redshift lädt Daten aus Datendateien oder aus einer Amazon DynamoDB-Tabelle in eine Tabelle. BigQuery verwendet nicht den Befehl SQL COPY, um Daten zu laden. Sie können jedoch eines bzw. eine der verschiedenen Nicht-SQL-Tools und -Optionen verwenden, um Daten in BigQuery-Tabellen zu laden. Sie können auch Datenpipeline-Senken verwenden, die in Apache Spark oder Apache Beam bereitgestellt werden, um Daten in BigQuery zu schreiben.

UPDATE-Anweisung

Die meisten Amazon Redshift-UPDATE-Anweisungen sind mit BigQuery kompatibel. Die folgende Tabelle zeigt Ausnahmen.

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

Hinweis: Alle UPDATE-Anweisungen in BigQuery erfordern das Schlüsselwort WHERE, gefolgt von einer Bedingung.
UPDATE table
SET column = DEFAULT [,...] [FROM ...]
[WHERE ...]		 UPDATE table
SET column = NULL [, ...]
[FROM ...]
WHERE ...

Hinweis: Der BigQuery-Befehl UPDATE unterstützt keine DEFAULT-Werte.

Wenn die Amazon Redshift-Anweisung UPDATE keine WHERE-Klausel enthält, sollte die BigQuery-UPDATE-Anweisung die Bedingung WHERE TRUE aufweisen.

DELETE- und TRUNCATE-Anweisungen

Die Anweisungen DELETE und TRUNCATE sind beide Möglichkeiten zum Entfernen von Zeilen aus einer Tabelle, ohne dass sich dies auf das Tabellenschema oder die Indexe auswirkt.

In Amazon Redshift wird die Anweisung TRUNCATE anstelle einer nicht qualifizierten DELETE-Anweisung empfohlen, da sie schneller ist und anschließend keine VACUUM- und ANALYZE-Vorgänge benötigt. Sie können jedoch DELETE-Anweisungen verwenden, um den gleichen Effekt zu erzielen.

In BigQuery muss die DELETE-Anweisung eine WHERE-Klausel enthalten. Weitere Informationen zu DELETE in BigQuery finden Sie in den BigQuery-DELETE-Beispielen in der DML-Dokumentation.

Amazon Redshift BigQuery
DELETE [FROM] table_name

TRUNCATE [TABLE] table_name		 DELETE FROM table_name
WHERE TRUE

BigQuery-DELETE-Anweisungen erfordern eine WHERE-Klausel.
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 )

In Amazon Redshift ermöglicht USING den Verweis auf zusätzliche Tabellen in der WHERE-Klausel. Dies kann in BigQuery mithilfe einer Unterabfrage in der WHERE-Klausel erreicht werden.

MERGE-Anweisung

Die MERGE-Anweisung kann die Vorgänge INSERT, UPDATE und DELETE in einer einzigen Upsert-Anweisung kombinieren und die Vorgänge atomar ausführen. Der MERGE-Vorgang muss mit maximal einer Quellzeile für jede Zielzeile übereinstimmen.

Amazon Redshift unterstützt keinen einzelnen MERGE-Befehl. Sie können jedoch in Amazon Redshift einen Zusammenführungsvorgang ausführen, indem Sie INSERT-, UPDATE- und DELETE-Vorgänge in einer Transaktion ausführen.

Zusammenführungsvorgang durch Ersetzen vorhandener Zeilen

In Amazon Redshift können alle Spalten in der Zieltabelle mit einer DELETE-Anweisung und dann mit einer INSERT-Anweisung überschrieben werden. Die DELETE-Anweisung entfernt Zeilen, die aktualisiert werden sollen, und dann fügt die INSERT-Anweisung die aktualisierten Zeilen ein. BigQuery-Tabellen sind auf 1.000 DML-Anweisungen pro Tag beschränkt. Daher sollten Sie die Anweisungen INSERT, UPDATE und DELETE in einer einzigen MERGE zusammenfassen. wie in der folgenden Tabelle dargestellt.

Amazon Redshift BigQuery
Weitere Informationen finden Sie unter Zusammenführungsvorgang durch Ersetzen vorhandener Zeilen durchführen.

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

Hinweis: Alle Spalten müssen aufgelistet werden, wenn alle Spalten aktualisiert werden.
Weitere Informationen finden Sie unter Zusammenführungsvorgang durch Angeben einer Spaltenliste durchführen.

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

In diesem Abschnitt werden Unterschiede in der Syntax der Datendefinitionssprache zwischen Amazon Redshift und BigQuery behandelt.

SELECT INTO-Anweisung

In Amazon Redshift kann die Anweisung SELECT INTO verwendet werden, um die Ergebnisse einer Abfrage in eine neue Tabelle einzufügen. Dabei werden die Tabellenerstellung und -einfügung kombiniert.

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 bietet mehrere Möglichkeiten, temporäre Tabellen zu emulieren. Weitere Informationen finden Sie im Abschnitt Temporäre Tabellen.

CREATE TABLE-Anweisung

Die meisten Amazon Redshift-CREATE TABLE-Anweisungen sind mit BigQuery kompatibel, mit Ausnahme der folgenden Syntaxelemente, die in BigQuery nicht verwendet werden:

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
)

Hinweis: UNIQUE- und PRIMARY KEY-Einschränkungen sind informationell und werden vom Amazon Redshift-System nicht durchgesetzt.		 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)]

Hinweis: UNIQUE- und PRIMARY KEY-Einschränkungen sind informationell und werden vom Amazon Redshift-System nicht durchgesetzt. 		CREATE TABLE table_name
(
col1 data_type1[,...]
)
PARTITION BY column_name
CLUSTER BY column_name [, ...]

Hinweis: BigQuery verwendet keine UNIQUE-, PRIMARY KEY- oder FOREIGN KEY-Tabelleneinschränkungen. Um eine ähnliche Optimierung zu erreichen, die diese Einschränkungen während der Abfrageausführung gewährleisten, partitionieren und clustern Sie Ihre BigQuery-Tabellen. CLUSTER BY unterstützt bis zu vier Spalten.
CREATE TABLE table_name
LIKE original_table_name 		In diesem Beispiel erfahren Sie, wie Sie mit den INFORMATION_SCHEMA-Tabellen Spaltennamen, Datentypen und NOT NULL-Einschränkungen in eine neue Tabelle kopieren.
CREATE TABLE table_name
(
col1 data_type1
)
BACKUP NO

Hinweis: In Amazon Redshift wird die Einstellung BACKUP NO angegeben, um Verarbeitungszeit zu sparen und den nötigen Speicherplatz zu reduzieren.		 Die Tabellenoption BACKUP NO wird nicht verwendet oder benötigt, da BigQuery automatisch bis zu 7 Tage an früheren Versionen aller Tabellen speichert, ohne dass sich dies auf die Verarbeitungszeit oder den abgerechneten Speicher auswirkt.
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 unterstützt das Clustering, sodass Schlüssel in sortierter Reihenfolge gespeichert werden können.
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 unterstützt auch die DDL-Anweisung CREATE OR REPLACE TABLE, mit der eine Tabelle überschrieben wird, wenn sie bereits vorhanden ist.

Die CREATE TABLE-Anweisung von BigQuery unterstützt auch die folgenden Klauseln, für die es kein Amazon Redshift-Äquivalent gibt:

Weitere Informationen zu CREATE TABLE in BigQuery finden Sie in den BigQuery-CREATE TABLE-Beispielen in der DML-Dokumentation.

Temporäre Tabellen

Amazon Redshift unterstützt temporäre Tabellen, die nur innerhalb der aktuellen Sitzung sichtbar sind. Es gibt mehrere Möglichkeiten, temporäre Tabellen in BigQuery zu emulieren:

  • Dataset-TTL: Erstellen Sie ein Dataset mit einer kurzen Lebensdauer (z. B. eine Stunde), damit alle im Dataset erstellten Tabellen praktisch temporär sind, da sie nicht länger als für die Lebensdauer des Datasets beibehalten werden. Sie können allen Tabellennamen in diesem Dataset „temp“ voranstellen, um deutlich zu machen, dass die Tabellen temporär sind.

  • Tabellen-TTL: Erstellen Sie eine Tabelle mit einer tabellenspezifischen kurzen Lebensdauer mithilfe von DDL-Anweisungen wie der folgenden:

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

CREATE VIEW-Anweisung

Die folgende Tabelle zeigt Entsprechungen zwischen Amazon Redshift und BigQuery für die Anweisung CREATE VIEW.

Amazon Redshift BigQuery
CREATE VIEW view_name AS SELECT ... 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 ...
Nicht unterstützt. CREATE VIEW IF NOT EXISTS c view_name
OPTIONS(view_option_list)
AS SELECT …

Erstellt nur dann eine neue Ansicht, wenn die Ansicht im angegebenen Dataset nicht vorhanden ist.
CREATE VIEW view_name
AS SELECT ...
WITH NO SCHEMA BINDING

In Amazon Redshift ist eine späte Bindungsansicht erforderlich, um auf eine externe Tabelle zu verweisen.		 In BigQuery müssen alle referenzierten Objekte bereits vorhanden sein, um eine Ansicht zu erstellen.

Mit BigQuery können Sie externe Datenquellen abfragen.

Nutzerdefinierte Funktionen (UDFs)

Mit einer UDF können Sie Funktionen für benutzerdefinierte Vorgänge erstellen. Diese Funktionen akzeptieren Spalten als Eingabe, führen Aktionen aus und geben das Ergebnis dieser Aktionen als Wert zurück.

Sowohl Amazon Redshift als auch BigQuery unterstützen UDFs mit SQL-Ausdrücken. Darüber hinaus können Sie in Amazon Redshift einePython-basierte UDF erstellen und in BigQuery können Sie eine JavaScript-basierte UDF erstellen.

Im GitHub-Repository für Google Cloud BigQuery-Dienstprogramme finden Sie eine Bibliothek gängiger BigQuery-UDFs.

CREATE FUNCTION-Syntax

Die folgende Tabelle befasst sich mit den Unterschieden in der SQL-UDF-Erstellungssyntax zwischen Amazon Redshift und 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

Hinweis: In einer BigQuery-SQL-UDF in BigQuery ist ein Rückgabedatentyp optional. BigQuery leitet den Ergebnistyp der Funktion aus dem SQL-Funktionsrumpf ab, wenn eine Abfrage die Funktion aufruft.
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

Hinweis: Die Volatilität der Funktion ist in BigQuery kein konfigurierbarer Parameter. Die gesamte BigQuery-UDF-Volatilität entspricht der IMMUTABLE-Volatilität von Amazon Redshift (d. h., sie führt keine Datenbanksuche durch und verwendet keine Informationen, die nicht direkt in der Argumentliste vorhanden sind).
CREATE [OR REPLACE] FUNCTION
function_name
([sql_arg_name sql_arg_data_type[,..]]) RETURNS data_type
IMMUTABLE
AS $$
SELECT_clause
$$ LANGUAGE sql

Hinweis: Amazon Redshift unterstützt lediglich eine SQL SELECT-Klausel als Funktionsdefinition. Außerdem darf die SELECT-Klausel keine der FROM, INTO, WHERE, GROUP BY, ORDER BY,- und LIMIT-Klauseln enthalten. 		CREATE [OR REPLACE] FUNCTION
function_name
([sql_arg_name sql_arg_data_type[,..]]) RETURNS data_type
AS sql_expression

Hinweis: BigQuery unterstützt alle SQL-Ausdrücke als Funktionsdefinition. Das Referenzieren von Tabellen, Ansichten oder Modellen wird jedoch nicht unterstützt.
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

Hinweis: Das Sprachliteral muss in einer GoogleSQL-UDF nicht angegeben werden. BigQuery interpretiert den SQL-Ausdruck standardmäßig. Außerdem die Amazon Redshift-Dollarzeichen-Kennzeichnung ($$) 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 ($$), um den Anfang und das Ende der Funktionsanweisungen anzugeben.

Für SQL-UDFs unterstützt Amazon Redshift nur die SQL-Klausel SELECT als Funktionsdefinition. Außerdem darf die SELECT-Klausel keine der FROM-, INTO-, WHERE-, GROUP
BY-, ORDER BY- und LIMIT -Klauseln enthalten.

Für Python-UDFs können Sie mit der Python 2.7-Standardbibliothek ein Python-Programm schreiben oder benutzerdefinierte Module importieren, indem Sie eines mit dem Befehl CREATE LIBRARY erstellen.		 In BigQuery müssen Sie den JavaScript-Code in Anführungszeichen einschließen. Weitere Informationen finden Sie unter Quoting-Regeln.

Für SQL-UDFs können Sie alle SQL-Ausdrücke als Funktionsdefinition verwenden. BigQuery unterstützt jedoch kein Referenzieren von Tabellen, Ansichten oder Modellen.

Für JavaScript-UDFs können Sie externe Codebibliotheken direkt mithilfe des OPTIONS -Abschnitts einbeziehen. Sie können auch das BigQuery-UDF-Testtool verwenden, um Ihre Funktionen zu testen.
Sprache Mit dem Literal LANGUAGE müssen Sie die Sprache entweder als sql für SQL-UDFs oder als plpythonu für Python-UDFs angeben. Sie müssen LANGUAGE für SQL-UDFs nicht angeben, müssen jedoch die Sprache als js für JavaScript-UDFs angeben.
Status Amazon Redshift unterstützt nicht das Erstellen temporärer UDFs.

Amazon Redshift bietet eine Option zum Definieren der Volatilität einer Funktion mit VOLATILE-, STABLE- oder IMMUTABLE -Literalen. Diese Option wird für die Optimierung durch das Abfrageoptimierungstool verwendet.		 BigQuery unterstützt sowohl persistente als auch temporäre UDFs. Sie können persistente UDFs für mehrere Abfragen verwenden, temporäre UDFs jedoch nur in einer einzigen Abfrage.

Die Funktionsvolatilität ist in BigQuery kein konfigurierbarer Parameter. Die gesamte BigQuery-UDF-Volatilität entspricht der IMMUTABLE -Volatilität von Amazon Redshift.
Sicherheit und Berechtigungen Zum Erstellen einer UDF benötigen Sie die Berechtigung zur Verwendung für Sprache für SQL oder plpythonu (Python). Standardmäßig wird USAGE ON LANGUAGE SQL zu PUBLIC zugewiesen. Sie müssen USAGE ON LANGUAGE PLPYTHONU jedoch bestimmten Nutzern oder Gruppen explizit zuweisen.
Außerdem müssen Sie ein Superuser sein, um eine UDF zu ersetzen.		 Es ist nicht erforderlich, in BigQuery explizite Berechtigungen zum Erstellen oder Löschen von UDF-Typen zuzuweisen. Jeder Nutzer, dem eine Rolle eines BigQuery-Datenbearbeiters zugewiesen ist (mit bigquery.routines.* als eine der Berechtigungen), kann Funktionen für das angegebene Dataset erstellen oder löschen.

BigQuery unterstützt auch das Erstellen benutzerdefinierter Rollen. Dies kann mit Cloud IAM verwaltet werden.
Beschränkungen Siehe Python-UDF-Limits. Siehe UDF-Limits.

Metadaten- und Transaktions-SQL-Anweisungen

Amazon Redshift BigQuery
SELECT * FROM STL_ANALYZE WHERE name
= 'T';		 Wird in BigQuery nicht verwendet. Sie müssen keine Statistiken erfassen, um die Abfrageleistung zu verbessern. Um Informationen zu Ihrer Datenverteilung abzurufen, können Sie ungefähre Aggregatfunktionen verwenden.
ANALYZE [[ table_name[(column_name
[, ...])]]		 Wird in BigQuery nicht verwendet.
LOCK TABLE table_name; Wird in BigQuery nicht verwendet.
BEGIN TRANSACTION; SELECT ...
END TRANSACTION;		 BigQuery verwendet die Snapshot-Isolation. Weitere Informationen finden Sie unter Konsistenzgarantien.
EXPLAIN ... Wird in BigQuery nicht verwendet.

Ähnliche Features sind die Erläuterung eines Abfrageplans in der BigQuery Google Cloud Console und im Audit-Logging in Cloud Monitoring.
SELECT * FROM SVV_TABLE_INFO WHERE
table = 'T';		 SELECT * EXCEPT(is_typed) FROM
mydataset.INFORMATION_SCHEMA.TABLES;

Weitere Informationen finden Sie unter Einführung in BigQuery-INFORMATION_SCHEMA.
VACUUM [table_name] Wird in BigQuery nicht verwendet. Geclusterte BigQuery-Tabellen werden automatisch sortiert.

Mehrfachanweisungen und mehrzeilige SQL-Anweisungen

Sowohl Amazon Redshift als auch BigQuery unterstützen Transaktionen (Sitzungen) und unterstützen daher durch Semikolons getrennte Anweisungen, die konsistent zusammen ausgeführt werden. Weitere Informationen finden Sie unter Transaktionen mit mehreren Anweisungen.

Prozedurale SQL-Anweisungen

CREATE PROCEDURE-Anweisung

Amazon Redshift BigQuery
CREATE or REPLACE PROCEDURE CREATE PROCEDURE, wenn ein Name erforderlich ist.

Verwenden Sie es andernfalls inline mit BEGIN oder in einer einzigen Zeile mit CREATE TEMP FUNCTION.
CALL CALL

Variablendeklaration und -zuweisung

Amazon Redshift BigQuery
DECLARE DECLARE

Deklariert eine Variable des angegebenen Typs.
SET SET

Legt fest, dass eine Variable den Wert des angegebenen Ausdrucks haben soll, oder legt auf der Grundlage des Ergebnisses mehrerer Ausdrücke mehrere Variablen gleichzeitig fest.

Fehlerbedingungs-Handler

In Amazon Redshift wird ein Fehler, der während der Ausführung einer gespeicherten Prozedur auftritt, den Ausführungsablauf beenden, die Transaktion beenden und ein Rollback der Transaktion durchführen. Diese Ergebnisse treten auf, weil Untertransaktionen nicht unterstützt werden. In einer von Amazon Redshift gespeicherten Prozedur ist RAISE das einzige unterstützte handler_statement. In BigQuery ist die Fehlerbehandlung ein Kernfeature des Hauptsteuerungsablaufs, ähnlich dem, was andere Sprachen mit TRY ... CATCH-Blöcken bieten.

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;

Cursor-Deklarationen und -Vorgänge

Da BigQuery keine Cursor oder Sitzungen unterstützt, werden die folgenden Anweisungen in BigQuery nicht verwendet:

Wenn Sie den Cursor verwenden, um eine Ergebnismenge zurückzugeben, können Sie mithilfe von temporären Tabellen in BigQuery ein ähnliches Verhalten erzielen.

Dynamische SQL-Anweisungen

Das Skriptfeature in BigQuery unterstützt dynamische SQL-Anweisungen wie jene, die in der folgenden Tabelle dargestellt sind.

Amazon Redshift BigQuery
EXECUTE EXECUTE IMMEDIATE

Anweisungen zum Kontrollfluss

Amazon Redshift BigQuery
IF..THEN..ELSIF..THEN..ELSE..END IF IF condition
THEN stmts
ELSE stmts
END IF
name CURSOR [ ( arguments ) ] FOR query Cursor oder Sitzungen werden in BigQuery nicht verwendet.
[< LOOP
sql_statement_list END LOOP;
WHILE condition LOOP stmts END LOOP WHILE condition
DO stmts
END WHILE
EXIT BREAK

Konsistenzgarantien und Transaktionsisolation

Sowohl Amazon Redshift als auch BigQuery sind atomar, d. h. ACID-konform auf Mutationsebene über viele Zeilen hinweg.

Transaktionen

Amazon Redshift unterstützt standardmäßig die serialisierbare Isolierung für Transaktionen. Mit Amazon Redshift können Sie eine der vier SQL-Standardtransaktionsisolationsebenen angeben, aber alle Isolationsebenen werden als serialisierbar verarbeitet.

BigQuery unterstützt auch Transaktionen. BigQuery sorgt mit der Snapshot-Isolation für eine optimistische Nebenläufigkeitserkennung (der erste Commit hat Vorrang), bei der eine Abfrage die letzten übergebenen Daten liest, bevor die Abfrage beginnt. Dieser Ansatz garantiert die gleiche Konsistenz auf Zeilen- und Mutationsbasis sowie zeilenübergreifend innerhalb derselben DML-Anweisung, vermeidet dabei jedoch Deadlocks. Bei mehreren DML-Aktualisierungen für dieselbe Tabelle wechselt BigQuery zur pessimistischen Nebenläufigkeitserkennung. Ladejobs können vollständig unabhängig ausgeführt und an Tabellen angefügt werden.

Rollback

Wenn Amazon Redshift während der Ausführung einer gespeicherten Prozedur einen Fehler feststellt, wird ein Rollback aller in einer Transaktion vorgenommenen Änderungen durchgeführt. Darüber hinaus können Sie die Transaktionssteuerungsanweisung ROLLBACK in einer gespeicherten Prozedur verwenden, um alle Änderungen zu verwerfen.

In BigQuery können Sie die ROLLBACK TRANSACTION-Anweisung verwenden.

Datenbanklimits

Die aktuellen Kontingente und Limits finden Sie in der öffentlichen BigQuery-Dokumentation. Viele Kontingente für Nutzer mit hohem Datenvolumen können durch Kontaktaufnahme mit dem Cloud-Supportteam erhöht werden. Die folgende Tabelle zeigt einen Vergleich der Amazon Redshift- und BigQuery-Datenbanklimits.

Limit Amazon Redshift BigQuery
Tabellen in jeder Datenbank für large- und xlarge-Clusterknotentypen 9.900 Uneingeschränkt
Tabellen in jeder Datenbank für 8xlarge-Clusterknotentypen 20.000 Uneingeschränkt
Benutzerdefinierte Datenbanken, die Sie für jeden Cluster erstellen können 60 Uneingeschränkt
Maximale Zeilengröße 4 MB 100 MB