מדריך לתרגום SQL ב-Amazon Redshift

במאמר הזה מפורטים הדמיון וההבדלים בתחביר של SQL בין Amazon Redshift לבין BigQuery, כדי לעזור לכם לתכנן את ההעברה. אפשר להשתמש בתרגום SQL באצווה כדי להעביר את סקריפטים ה-SQL בכמות גדולה, או בתרגום SQL אינטראקטיבי כדי לתרגם שאילתות אד-הוק.

המדריך הזה מיועד לאדריכלים ארגוניים, לאדמינים של מסדי נתונים, למפתחי אפליקציות ולמומחי אבטחת IT. ההנחה היא שאתם מכירים את Amazon Redshift.

סוגי נתונים

בקטע הזה מוצגות מקבילות בין סוגי נתונים ב-Amazon Redshift וב-BigQuery.

‫Amazon Redshift BigQuery Notes
סוג הנתונים כינוי סוג הנתונים
SMALLINT INT2 INT64 ‫SMALLINT ב-Amazon Redshift הוא 2 בייט, לעומת INT64 ב-BigQuery שהוא 8 בייט.
INTEGER

INT, INT4

 INT64 ‫INTEGER ב-Amazon Redshift הוא 4 בייט, לעומת INT64 ב-BigQuery שהוא 8 בייט.
BIGINT INT8 INT64 הגודל של BIGINT ב-Amazon Redshift ושל INT64 ב-BigQuery הוא 8 בייט.
DECIMAL NUMERIC NUMERIC
REAL FLOAT4 FLOAT64 ‫REAL ב-Amazon Redshift הוא 4 בייט, לעומת FLOAT64 ב-BigQuery שהוא 8 בייט.
DOUBLE PRECISION

FLOAT8, FLOAT

 FLOAT64
BOOLEAN BOOL BOOL ב-BOOLEAN של Amazon Redshift אפשר להשתמש ב-TRUE, ב-t, ב-true, ב-y, ב-yes וב-1 כערכים מילוליים חוקיים לערך true. סוג הנתונים BOOL ב-BigQuery הוא לא תלוי רישיות TRUE.
CHAR

CHARACTER, NCHAR, BPCHAR

STRING
VARCHAR

CHARACTER VARYING, NVARCHAR, TEXT

STRING
DATE DATE
TIMESTAMP TIMESTAMP WITHOUT TIME ZONE DATETIME
TIMESTAMPTZ

TIMESTAMP WITH TIME ZONE

TIMESTAMP הערה: ב-BigQuery, נעשה שימוש באזורי זמן כשמנתחים חותמות זמן או כשמעצבים חותמות זמן לתצוגה. חותמת זמן בפורמט מחרוזת עשויה לכלול אזור זמן, אבל כש-BigQuery מנתח את המחרוזת, הוא מאחסן את חותמת הזמן בזמן UTC המקביל. אם לא מציינים אזור זמן באופן מפורש, המערכת משתמשת באזור הזמן שמוגדר כברירת מחדל, UTC. אפשר להשתמש בשמות של אזורי זמן או בהפרש משעון UTC בפורמט ‎ (-|+)HH:MM, אבל אי אפשר להשתמש בקיצורים של אזורי זמן כמו PDT.
GEOMETRY GEOGRAPHY תמיכה בהרצת שאילתות על נתונים גיאו-מרחביים.

ב-BigQuery יש גם את סוגי הנתונים הבאים שאין להם מקבילה ישירה ב-Amazon Redshift:

סוגי המרות משתמעים

כשמבצעים מיגרציה ל-BigQuery, צריך להמיר את רוב ההמרות המרומזות של Amazon Redshift להמרות מפורשות של BigQuery, למעט סוגי הנתונים הבאים, ש-BigQuery ממיר באופן מרומז.

מערכת BigQuery מבצעת המרות מרומזות לסוגי הנתונים הבאים:

מהסוג BigQuery לסוג BigQuery

INT64

FLOAT64

INT64

NUMERIC

NUMERIC

FLOAT64

ב-BigQuery מתבצעות גם המרות מרומזות של הערכים הקבועים הבאים:

מהסוג BigQuery לסוג BigQuery
STRING literal
(e.g. "2008-12-25")

DATE

STRING literal
(e.g. "2008-12-25 15:30:00")

TIMESTAMP

STRING literal
(e.g. "2008-12-25T07:30:00")

DATETIME

STRING literal
(לדוגמה, ‎"15:30:00")

TIME

סוגי המרות מפורשים

אפשר להמיר סוגי נתונים של Amazon Redshift שלא מומרים באופן מרומז ב-BigQuery באמצעות הפונקציה CAST(expression AS type) של BigQuery או באמצעות כל אחת מפונקציות ההמרה DATE ו-TIMESTAMP.

כשמעבירים את השאילתות, צריך לשנות את כל המקרים של הפונקציה CONVERT(type, expression) של Amazon Redshift (או התחביר ::) לפונקציה CAST(expression AS type) של BigQuery, כמו שמוצג בטבלה שבקטע פונקציות לעיצוב סוגי נתונים.

תחביר של שאילתות

בקטע הזה מוסברים ההבדלים בתחביר של שאילתות בין Amazon Redshift לבין BigQuery.

SELECT דוחות

רוב ההצהרות של Amazon Redshift‏ SELECT תואמות ל-BigQuery. בטבלה הבאה מפורטים כמה הבדלים קלים.

‫Amazon Redshift BigQuery

SELECT TOP number expression
FROM table

SELECT expression
FROM table
ORDER BY expression DESC
LIMIT number

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

הערה: ב-Redshift אפשר ליצור כינוי ולהפנות אליו באותה SELECT הצהרה.

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

‫BigQuery תומך גם בביטויים הבאים בהצהרות SELECT, שאין להם מקבילה ב-Amazon Redshift:

סעיף FROM

סעיף FROM בשאילתה מפרט את ההפניות לטבלאות שמהן נבחרים הנתונים. ב-Amazon Redshift, הפניות אפשריות לטבלאות כוללות טבלאות, תצוגות ושאילתות משנה. כל ההפניות האלה לטבלאות נתמכות ב-BigQuery.

אפשר להפנות לטבלאות BigQuery באמצעות הפריטים הבאים בסעיף FROM:

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

‫BigQuery תומך גם בהפניות נוספות לטבלאות:

JOIN סוגים

גם Amazon Redshift וגם BigQuery תומכים בסוגים הבאים של פעולות join:

  • [INNER] JOIN
  • LEFT [OUTER] JOIN
  • RIGHT [OUTER] JOIN
  • FULL [OUTER] JOIN
  • ‫CROSS JOIN והמקבילה implicit comma cross join.

בטבלה הבאה מפורטים כמה הבדלים קלים.

‫Amazon Redshift BigQuery

SELECT col
FROM table1
NATURAL INNER JOIN
table2

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


הערה: ב-BigQuery, סעיפי JOIN מחייבים תנאי JOIN, אלא אם הסעיף הוא CROSS JOIN או שאחת מהטבלאות המצורפות היא שדה בתוך סוג נתונים או מערך.

סעיף WITH

סעיף WITH ב-BigQuery כולל שאילתה משנית אחת או יותר עם שם, שמופעלת כשמשפט SELECT הבא מפנה אליה. התנהגות הסעיפים של Amazon Redshift WITH זהה להתנהגות הסעיפים של BigQuery, למעט העובדה שאפשר להעריך את הסעיף פעם אחת ולעשות שימוש חוזר בתוצאות שלו.

הגדרת אופרטורים

יש כמה הבדלים קלים בין אופרטורים של קבוצות ב-Amazon Redshift לבין אופרטורים של קבוצות ב-BigQuery. אבל כל הפעולות שניתן לבצע ב-Amazon Redshift ניתנות לשחזור ב-BigQuery.

‫Amazon Redshift BigQuery

SELECT * FROM table1
UNION
SELECT * FROM table2

SELECT * FROM table1
UNION DISTINCT
SELECT * FROM table2

הערה: גם BigQuery וגם Amazon Redshift תומכים באופרטור UNION ALL.

SELECT * FROM table1
INTERSECT
SELECT * FROM table2

SELECT * FROM table1
INTERSECT DISTINCT
SELECT * FROM table2

SELECT * FROM table1
EXCEPT
SELECT * FROM table2

SELECT * FROM table1
EXCEPT DISTINCT
SELECT * FROM table2

SELECT * FROM table1
MINUS
SELECT * FROM table2

SELECT * FROM table1
EXCEPT DISTINCT
SELECT * FROM table2

SELECT * FROM table1
UNION
SELECT * FROM table2
EXCEPT
SELECT * FROM table3

SELECT * FROM table1
UNION ALL
(
SELECT * FROM table2
EXCEPT
SELECT * FROM table3
)


הערה: ב-BigQuery צריך להשתמש בסוגריים כדי להפריד בין פעולות שונות על קבוצות. אם אותו אופרטור קבוצה חוזר על עצמו, אין צורך בסוגריים.

סעיף ORDER BY

יש כמה הבדלים קלים בין סעיפי Amazon Redshift‏ ORDER BY לבין סעיפי BigQuery‏ ORDER BY.

Amazon Redshift BigQuery
ב-Amazon Redshift, ‏ NULLs מדורגים אחרונים כברירת מחדל (סדר עולה). ב-BigQuery, ‏ NULL מדורגים ראשונים כברירת מחדל (סדר עולה).

SELECT *
FROM table
ORDER BY expression
LIMIT ALL

SELECT *
FROM table
ORDER BY expression



הערה: ב-BigQuery לא נעשה שימוש בתחביר LIMIT ALL, אבל ORDER BY ממיין את כל השורות כברירת מחדל, ולכן מתקבלת התנהגות זהה לזו של פסוקית LIMIT ALL ב-Amazon Redshift. מומלץ מאוד לכלול סעיף LIMIT בכל סעיף ORDER BY. הזמנת כל שורות התוצאות שלא לצורך פוגעת בביצועים של הרצת השאילתה.

SELECT *
FROM table
ORDER BY expression
OFFSET 10

SELECT *
FROM table
ORDER BY expression
LIMIT count OFFSET 10



הערה: ב-BigQuery, צריך להשתמש ב-OFFSET יחד עם LIMIT count. חשוב להגדיר את הערך של count INT64 למספר השורות המינימלי שנדרש להזמנה. מיון של כל שורות התוצאות
פוגע בביצועים של השאילתה שלא לצורך.

תנאים

בטבלה הבאה מוצגים תנאים של Amazon Redshift, או פרדיקטים, שספציפיים ל-Amazon Redshift וחייבים להיות מומרים למקבילים שלהם ב-BigQuery.

‫Amazon Redshift BigQuery

a = ANY (subquery)

a = SOME (subquery)

a IN subquery

a <> ALL (subquery)

a != ALL (subquery)

a NOT IN subquery

a IS UNKNOWN

expression ILIKE pattern

a IS NULL

LOWER(expression) LIKE LOWER(pattern)

expression LIKE pattern ESCAPE 'escape_char'

expression LIKE pattern


הערה: BigQuery לא תומך בתווי בריחה מותאמים אישית. צריך להשתמש בשני לוכסנים הפוכים \\ כתווי escape ב-BigQuery.

expression [NOT] SIMILAR TO pattern

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


הערה: אם מציינים את NOT, צריך להוסיף את הביטוי IF שלמעלה לביטוי NOT, כמו שמוצג בהמשך:

NOT(
IF(
LENGTH(...
)

expression [!] ~ pattern

[NOT] REGEXP_CONTAINS(
expression,
regex
)

פונקציות

בקטעים הבאים מפורטות פונקציות של Amazon Redshift והפונקציות המקבילות שלהן ב-BigQuery.

פונקציות צבירה

בטבלה הבאה מוצגים מיפויים בין פונקציות נפוצות של Amazon Redshift לחישוב מצטבר, לחישוב מצטבר אנליטי ולחישוב מצטבר משוער, לבין הפונקציות המקבילות שלהן ב-BigQuery.

Amazon Redshift BigQuery
APPROXIMATE COUNT(DISTINCT expression) APPROX_COUNT_DISTINCT(expression)
APPROXIMATE PERCENTILE_DISC(
percentile
) WITHIN GROUP (ORDER BY expression)		 APPROX_QUANTILES(expression, 100)
[OFFSET(CAST(TRUNC(percentile * 100) as INT64))]
AVG([DISTINCT] expression) AVG([DISTINCT] expression)
COUNT(expression) COUNT(expression)
LISTAGG(
[DISTINCT] aggregate_expression
[, delimiter] )
[WITHIN GROUP (ORDER BY order_list)] 		STRING_AGG(
[DISTINCT] aggregate_expression
[, delimiter]
[ORDER BY order_list] )
MAX(expression) MAX(expression)
MEDIAN(median_expression) PERCENTILE_CONT( median_expression, 0.5 ) OVER()
MIN(expression) MIN(expression)
PERCENTILE_CONT(
percentile
) WITHIN GROUP (ORDER BY expression)		 PERCENTILE_CONT(
median_expression,
percentile
) OVER()

הערה: לא כולל תרחישי שימוש בצבירה.
STDDEV([DISTINCT] expression) STDDEV([DISTINCT] expression)
STDDEV_SAMP([DISTINCT] expression) STDDEV_SAMP([DISTINCT] expression)
STDDEV_POP([DISTINCT] expression) STDDEV_POP([DISTINCT] expression)
SUM([DISTINCT] expression) SUM([DISTINCT] expression)
VARIANCE([DISTINCT] expression) VARIANCE([DISTINCT] expression)
VAR_SAMP([DISTINCT] expression) VAR_SAMP([DISTINCT] expression)
VAR_POP([DISTINCT] expression) VAR_POP([DISTINCT] expression)

ב-BigQuery יש גם את הפונקציות הבאות: aggregate,‏ aggregate analytic ו-approximate aggregate. אין להן פונקציות מקבילות ב-Amazon Redshift.

פונקציות צבירה ברמת הביט

בטבלה הבאה מוצגים מיפויים בין פונקציות נפוצות של Amazon Redshift לסיכום לפי ביטים לבין הפונקציות המקבילות שלהן ב-BigQuery.

‫Amazon Redshift BigQuery
BIT_AND(expression) BIT_AND(expression)
BIT_OR(expression) BIT_OR(expression)
BOOL_AND>(expression) LOGICAL_AND(expression)
BOOL_OR(expression) LOGICAL_OR(expression)

ב-BigQuery יש גם את פונקציית הצבירה לפי ביטים הבאה, שאין לה מקבילה ישירה ב-Amazon Redshift:

פונקציות חלון

בטבלה הבאה מוצגים מיפויים בין פונקציות חלון נפוצות ב-Amazon Redshift לבין הפונקציות המקבילות ב-BigQuery. פונקציות חלון ב-BigQuery כוללות פונקציות צבירה אנליטיות, פונקציות צבירה, פונקציות ניווט ופונקציות מספור.


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

ביטויים מותנים

בטבלה הבאה מוצגים מיפויים בין ביטויים נפוצים של תנאים ב-Amazon Redshift לבין הביטויים המקבילים ב-BigQuery.

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

ב-BigQuery יש גם את הביטויים המותנים הבאים, שאין להם מקבילה ישירה ב-Amazon Redshift:

פונקציות של תאריך ושעה

בטבלה הבאה מוצגים מיפויים בין פונקציות נפוצות של תאריך ושעה ב-Amazon Redshift לבין הפונקציות המקבילות ב-BigQuery. פונקציות התאריך והשעה ב-BigQuery כוללות פונקציות תאריך, פונקציות של תאריך ושעה, פונקציות, פונקציות שעה ופונקציות של חותמת זמן.

חשוב לזכור שפונקציות שנראות זהות ב-Amazon Redshift וב-BigQuery עשויות להחזיר סוגי נתונים שונים.

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

הערה: נעשה שימוש באזורי זמן כשמנתחים חותמות זמן או כשמעצבים חותמות זמן לתצוגה. חותמת זמן בפורמט מחרוזת עשויה לכלול אזור זמן, אבל כש-BigQuery מנתח את המחרוזת, הוא מאחסן את חותמת הזמן בשעה המקבילה לפי שעון UTC. אם לא מציינים אזור זמן באופן מפורש, המערכת משתמשת באזור הזמן שמוגדר כברירת מחדל, UTC. אפשר להשתמש בשמות של אזורי זמן או בהפרש משעון UTC (‎-HH:MM), אבל אי אפשר להשתמש בקיצורים של אזורי זמן (כמו PDT).
CONVERT_TIMEZONE(
[source_timezone],
target_timezone,
timestamp
)		 PARSE_TIMESTAMP(
"%c%z",
FORMAT_TIMESTAMP(
"%c%z",
timestamp,
target_timezone
)
)

הערה: source_timezone הוא UTC ב-BigQuery.
CURRENT_DATE

הערה: הפונקציה מחזירה את תאריך ההתחלה של העסקה הנוכחית לפי אזור הזמן של הסשן הנוכחי (ברירת המחדל היא UTC). 		CURRENT_DATE()

הערה: הפונקציה מחזירה את תאריך ההתחלה של הדוח הנוכחי באזור הזמן UTC.
DATE_CMP(date1, date2) CASE
WHEN date1 = date2 THEN 0
WHEN date1 > date2 THEN 1
ELSE -1
END
DATE_CMP_TIMESTAMP(date1, date2) CASE
WHEN date1 = CAST(date2 AS DATE)
THEN 0
WHEN date1 > CAST(date2 AS DATE)
THEN 1
ELSE -1
END
DATE_CMP_TIMESTAMPTZ(date, timestamptz) CASE
WHEN date > DATE(timestamptz)
THEN 1
WHEN date < DATE(timestamptz)
THEN -1
ELSE 0
END
DATE_PART_YEAR(date) EXTRACT(YEAR FROM date)
DATEADD(date_part, interval, date) CAST(
DATE_ADD(
date,
INTERVAL interval datepart
)
AS TIMESTAMP
)
DATEDIFF(
date_part,
date_expression1,
date_expression2
) 		DATE_DIFF(
date_expression2,
date_expression1,
date_part
)
DATE_PART(date_part, date) EXTRACT(date_part FROM date)
DATE_TRUNC('date_part', timestamp) TIMESTAMP_TRUNC(timestamp, date_part)
EXTRACT(date_part FROM timestamp) EXTRACT(date_part FROM timestamp)
GETDATE() PARSE_TIMESTAMP(
"%c",
FORMAT_TIMESTAMP(
"%c",
CURRENT_TIMESTAMP()
)
)
INTERVAL_CMP(
interval_literal1,
interval_literal2
) 		ב-Redshift, שנה מורכבת מ-360 ימים. ב-BigQuery, אפשר להשתמש בפונקציה הבאה בהגדרת המשתמש (UDF) כדי לנתח מרווח זמן ב-Redshift ולתרגם אותו לשניות.

CREATE TEMP FUNCTION
parse_interval(interval_literal STRING) AS (
(select sum(case
when unit in ('minutes', 'minute', 'm' )
then num * 60
when unit in ('hours', 'hour', 'h') then num
* 60 * 60
when unit in ('days', 'day', 'd' ) then num
* 60 * 60 * 24
when unit in ('weeks', 'week', 'w') then num
* 60 * 60 * 24 * 7
when unit in ('months', 'month' ) then num *
60 * 60 * 24 * 30
when unit in ('years', 'year') then num * 60
* 60 * 24 * 360
else num
end)
from (
select
cast(regexp_extract(value,
r'^[0-9]*\.?[0-9]+') as numeric) num,
substr(value, length(regexp_extract(value,
r'^[0-9]*\.?[0-9]+')) + 1) unit
from
UNNEST(
SPLIT(
replace(
interval_literal, ' ', ''), ',')) value
)));

כדי להשוות בין ערכים מילוליים של מרווחים, מבצעים:

IF(
parse_interval(interval_literal1) >
parse_interval(interval_literal2),
1,
IF(
parse_interval(interval_literal1) >
parse_interval(interval_literal2),
-1,
0
)
)
LAST_DAY(date) DATE_SUB(
DATE_ADD(
date,
INTERVAL 1 MONTH
),
INTERVAL 1 DAY
)
MONTHS_BETWEEN(
date1,
date2
) 		DATE_DIFF(
date1,
date2,
MONTH
)
NEXT_DAY(date, day) DATE_ADD(
DATE_TRUNC(
date,
WEEK(day)
),
INTERVAL 1 WEEK
)
SYSDATE

הערה: הפונקציה מחזירה את חותמת הזמן של ההתחלה של העסקה הנוכחית באזור הזמן הנוכחי של הסשן (UTC כברירת מחדל). 		CURRENT_TIMESTAMP()

הערה: הפונקציה מחזירה את חותמת הזמן של ההתחלה של הדוח הנוכחי באזור הזמן UTC.
TIMEOFDAY() FORMAT_TIMESTAMP(
"%a %b %d %H:%M:%E6S %E4Y %Z",
CURRENT_TIMESTAMP())
TIMESTAMP_CMP(
timestamp1,
timestamp2
)		 CASE
WHEN timestamp1 = timestamp2
THEN 0
WHEN timestamp1 > timestamp2
THEN 1
ELSE -1
END
TIMESTAMP_CMP_DATE(
timestamp,
date
) 		CASE
WHEN
EXTRACT(
DATE FROM timestamp
) = date
THEN 0
WHEN
EXTRACT(
DATE FROM timestamp) > date
THEN 1
ELSE -1
END
TIMESTAMP_CMP_TIMESTAMPTZ(
timestamp,
timestamptz
)

הערה: ב-Redshift מתבצעת השוואה בין חותמות הזמן באזור הזמן שמוגדר לסשן של המשתמש. אזור הזמן שמוגדר כברירת מחדל לסשנים של משתמשים הוא UTC. 		CASE
WHEN timestamp = timestamptz
THEN 0
WHEN timestamp > timestamptz
THEN 1
ELSE -1
END

הערה: ב-BigQuery מתבצעת השוואה בין חותמות זמן באזור הזמן UTC.
TIMESTAMPTZ_CMP(
timestamptz1,
timestamptz2
)

הערה: ב-Redshift מתבצעת השוואה בין חותמות הזמן באזור הזמן שמוגדר לסשן של המשתמש. אזור הזמן שמוגדר כברירת מחדל לסשנים של משתמשים הוא UTC. 		CASE
WHEN timestamptz1 = timestamptz2
THEN 0
WHEN timestamptz1 > timestamptz2
THEN 1
ELSE -1
END

הערה: ב-BigQuery מתבצעת השוואה בין חותמות זמן באזור הזמן UTC.
TIMESTAMPTZ_CMP_DATE(
timestamptz,
date
)

הערה: ב-Redshift מתבצעת השוואה בין חותמות הזמן באזור הזמן שמוגדר לסשן של המשתמש. אזור הזמן שמוגדר כברירת מחדל לסשנים של משתמשים הוא UTC. 		CASE
WHEN
EXTRACT(
DATE FROM timestamptz) = date
THEN 0
WHEN
EXTRACT(
DATE FROM timestamptz) > date
THEN 1
ELSE -1
END

הערה: ב-BigQuery מתבצעת השוואה בין חותמות זמן באזור הזמן UTC.
TIMESTAMPTZ_CMP_TIMESTAMP(
timestamptz,
Timestamp
)

הערה: ב-Redshift מתבצעת השוואה בין חותמות הזמן באזור הזמן שמוגדר לסשן של המשתמש. אזור הזמן שמוגדר כברירת מחדל לסשנים של משתמשים הוא UTC. 		CASE
WHEN timestamp = timestamptz
THEN 0
WHEN timestamp > timestamptz
THEN 1
ELSE -1
END

הערה: ב-BigQuery מתבצעת השוואה בין חותמות זמן באזור הזמן UTC.
TIMEZONE(
timezone,
Timestamptz_or_timestamp
) 		PARSE_TIMESTAMP(
"%c%z", FORMAT_TIMESTAMP(
"%c%z",
timestamptz_or_timestamp,
timezone
)
)

הערה: נעשה שימוש באזורי זמן כשמנתחים חותמות זמן או כשמעצבים חותמות זמן לתצוגה. חותמת זמן בפורמט מחרוזת עשויה לכלול אזור זמן, אבל כש-BigQuery מנתח את המחרוזת, הוא מאחסן את חותמת הזמן בשעה המקבילה לפי שעון UTC. אם לא מציינים אזור זמן באופן מפורש, המערכת משתמשת באזור הזמן שמוגדר כברירת מחדל, UTC. אפשר להשתמש בשמות של אזורי זמן או בהפרש משעון UTC (‎-HH:MM), אבל קיצורים של אזורי זמן (כמו PDT) אינם נתמכים.
TO_TIMESTAMP(timestamp, format) PARSE_TIMESTAMP(
format,
FORMAT_TIMESTAMP(
format,
timestamp
)
)

הערה: ב-BigQuery יש קבוצה שונה של רכיבי פורמט. אזורי זמן משמשים לניתוח חותמות זמן או לעיצוב חותמות זמן לתצוגה. חותמת זמן בפורמט מחרוזת עשויה לכלול אזור זמן, אבל כש-BigQuery מנתח את המחרוזת, הוא מאחסן את חותמת הזמן בזמן UTC המקביל. אם לא מציינים אזור זמן באופן מפורש, המערכת משתמשת באזור הזמן שמוגדר כברירת מחדל, UTC. שמות של אזורי זמן או הפרש השעות לעומת UTC (‎-HH:MM) נתמכים במחרוזת הפורמט, אבל קיצורים של אזורי זמן (כמו PDT) לא נתמכים.
TRUNC(timestamp) CAST(timestamp AS DATE)

ב-BigQuery יש גם את הפונקציות הבאות של תאריך ושעה, שאין להן מקבילה ישירה ב-Amazon Redshift:

אופרטורים מתמטיים

בטבלה הבאה מוצגים מיפויים בין אופרטורים מתמטיים נפוצים ב-Amazon Redshift לבין האופרטורים המקבילים ב-BigQuery.

‫Amazon Redshift BigQuery

X + Y

X + Y

X - Y

X - Y

X * Y

X * Y

X / Y


הערה: אם האופרטור
מבצע חלוקת מספרים שלמים (כלומר, אם X ו-Y הם מספרים שלמים), הפונקציה מחזירה מספר שלם. אם האופרטור מבצע חילוק של מספרים לא שלמים, מוחזר מספר לא שלם.		 אם מדובר בחלוקה של מספרים שלמים:
CAST(FLOOR(X / Y) AS INT64)

אם לא מדובר בחלוקה של מספרים שלמים:

CAST(X / Y AS INT64)


הערה: פעולת חילוק ב-BigQuery מחזירה מספר לא שלם.
כדי למנוע שגיאות מפעולת חילוק (שגיאה של חילוק באפס), משתמשים ב- SAFE_DIVIDE(X, Y) או ב-IEEE_DIVIDE(X, Y).

X % Y

MOD(X, Y)


הערה: כדי למנוע שגיאות מפעולת חילוק (שגיאה של חילוק באפס), משתמשים ב-SAFE.MOD(X, Y). SAFE.MOD(X, 0) התוצאה היא 0.

X ^ Y

POW(X, Y)

POWER(X, Y)


הערה: בניגוד ל-Amazon Redshift, האופרטור ^ ב-BigQuery מבצע XOR ברמת הביטים.

| / X

SQRT(X)


הערה: כדי למנוע שגיאות מפעולת שורש ריבועי (קלט שלילי), משתמשים ב-SAFE.SQRT(X). קלט שלילי עם SAFE.SQRT(X) מוביל ל NULL.

|| / X

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


הערה: הפונקציה POWER(X, Y) של BigQuery מחזירה שגיאה אם X הוא ערך סופי שקטן מ-0 ו-Y הוא לא מספר שלם.

@ X

ABS(X)

X << Y

X << Y


הערה: האופרטור הזה מחזיר 0 או רצף בייטים של b'\x00' אם האופרנד השני Y גדול מאורך הסיביות של האופרנד הראשון X או שווה לו (לדוגמה, 64 אם X הוא מסוג INT64). האופרטור הזה מחזיר שגיאה אם Y הוא שלילי.

X >> Y

X >> Y


הערה: מזיז את האופרנד הראשון X ימינה. האופרטור הזה לא מבצע הרחבה של סיביות הסימן עם סוג חתום (הוא ממלא את הסיביות הריקות בצד שמאל באפס). האופרטור הזה מחזיר 0 או רצף של בייטים
b'\x00' אם האופרנד השני Y גדול מאורך הסיביות של האופרנד הראשון X או שווה לו (לדוגמה, 64 אם X הוא מסוג INT64). האופרטור הזה מחזיר שגיאה אם Y הוא שלילי.

X & Y

X & Y

X | Y

X | Y

~X

~X

ב-BigQuery יש גם את האופרטור המתמטי הבא, שאין לו מקבילה ישירה ב-Amazon Redshift:

פונקציות מתמטיות

‫Amazon Redshift BigQuery
ABS(number) ABS(number)
ACOS(number) ACOS(number)
ASIN(number) ASIN(number)
ATAN(number) ATAN(number)
ATAN2(number1, number2) ATAN2(number1, number2)
CBRT(number) POWER(number, 1/3)
CEIL(number) CEIL(number)
CEILING(number) CEILING(number)
CHECKSUM(expression) FARM_FINGERPRINT(expression)
COS(number) COS(number)
COT(number) 1/TAN(number)
DEGREES(number) number*180/ACOS(-1)
DEXP(number) EXP(number)
DLOG1(number) LN(number)
DLOG10(number) LOG10(number)
EXP(number) EXP(number)
FLOOR(number) FLOOR(number)
LNnumber) LN(number)
LOG(number) LOG10(number)
MOD(number1, number2) MOD(number1, number2)
PI ACOS(-1)
POWER(expression1, expression2) POWER(expression1, expression2)
RADIANS(number) ACOS(-1)*(number/180)
RANDOM() RAND()
ROUND(number [, integer]) ROUND(number [, integer])
SIN(number) SIN(number)
SIGN(number) SIGN(number)
SQRT(number) SQRT(number)
TAN(number) TAN(number)
TO_HEX(number) FORMAT('%x', number)
TRUNC(number [, integer])+-+++ TRUNC(number [, integer])

פונקציות מחרוזת

‫Amazon Redshift BigQuery
string1 || string2 CONCAT(string1, string2)
BPCHARCMP(string1, string2) CASE
WHEN string1 = string2 THEN 0
WHEN string1 > string2 THEN 1
ELSE -1
END
BTRIM(string [, matching_string]) TRIM(string [, matching_string])
BTTEXT_PATTERN_CMP(string1, string2) CASE
WHEN string1 = string2 THEN 0
WHEN string1 > string2 THEN 1
ELSE -1
END
CHAR_LENGTH(expression) CHAR_LENGTH(expression)
CHARACTER_LENGTH(expression) CHARACTER_LENGTH(expression)
CHARINDEX(substring, string) STRPOS(string, substring)
CHR(number) CODE_POINTS_TO_STRING([number])
CONCAT(string1, string2) CONCAT(string1, string2)

הערה: הפונקציה CONCAT(...)‎ של BigQuery תומכת ב
שרשור של מספר כלשהו של מחרוזות.
CRC32 פונקציה בהגדרת המשתמש מותאמת אישית
FUNC_SHA1(string) SHA1(string)
INITCAP INITCAP
LEFT(string, integer) SUBSTR(string, 0, integer)
RIGHT(string, integer) SUBSTR(string, -integer)
LEN(expression) LENGTH(expression)
LENGTH(expression) LENGTH(expression)
LOWER(string) LOWER(string)
LPAD(string1, length[, string2]) LPAD(string1, length[, string2])
RPAD(string1, length[, string2]) RPAD(string1, length[, string2])
LTRIM(string, trim_chars) LTRIM(string, trim_chars)
MD5(string) MD5(string)
OCTET_LENGTH(expression) BYTE_LENGTH(expression)
POSITION(substring IN string) STRPOS(string, substring)
QUOTE_IDENT(string) CONCAT('"',string,'"')
QUOTE_LITERAL(string) CONCAT("'",string,"'")
REGEXP_COUNT( source_string, pattern
[,position]
) 		‫ARRAY_LENGTH( REGEXP_EXTRACT_ALL(
source_string,
pattern
)
)

אם מציינים את position:

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

הערה: BigQuery מספק תמיכה בביטויים רגולריים באמצעות ספריית re2. אפשר לעיין במסמכי התיעוד של הספרייה כדי לראות את התחביר של הביטויים הרגולריים.
REGEXP_INSTR(
source_string,
pattern
[,position
[,occurrence]] ) 		‫IFNULL( STRPOS(
source_string, REGEXP_EXTRACT(
source_string,
pattern)
),0)

אם מציינים את source_string:

‫REGEXP_REPLACE(
source_string,

pattern,
replace_string
)

אם מציינים את position:

‫IFNULL( STRPOS(
SUBSTR(source_string, IF(position
<= 0, 1, position)), REGEXP_EXTRACT(
SUBSTR(source_string, IF(position <= 0, 1, position)),
pattern)
) + IF(position <= 0, 1, position) - 1, 0)

אם מציינים את occurrence:

‫IFNULL( STRPOS(
SUBSTR(source_string, IF(position
<= 0, 1, position)), REGEXP_EXTRACT_ALL(
SUBSTR(source_string, IF(position <= 0, 1, position)),
pattern
)[SAFE_ORDINAL(occurrence)]
) + IF(position <= 0, 1, position) - 1, 0)

הערה: BigQuery תומך בביטויים רגולריים באמצעות הספרייה re2. אפשר לעיין במסמכי התיעוד של הספרייה כדי לראות את התחביר של הביטויים הרגולריים.
REGEXP_REPLACE( source_string,
pattern
[, replace_string [, position]]
) 		‫REGEXP_REPLACE(
source_string,
pattern,
""
)

אם מציינים את source_string:

REGEXP_REPLACE(
source_string,

pattern, replace_string
)

אם מציינים את position:

CASE
WHEN position > LENGTH(source_string) THEN source_string
WHEN position <= 0 THEN REGEXP_REPLACE(
source_string, pattern,
""
) ELSE
CONCAT( SUBSTR(
source_string, 1, position - 1), REGEXP_REPLACE(
SUBSTR(source_string, position), pattern,
replace_string
)
) END
REGEXP_SUBSTR( source_string, pattern
[, position
[, occurrence]] ) 		REGEXP_EXTRACT(
source_string, pattern
)

אם מציינים את position:

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

)

אם מציינים את occurrence:

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


pattern
)[SAFE_ORDINAL(occurrence)]

הערה: BigQuery תומך בביטויים רגולריים באמצעות ספריית re2. אפשר לעיין במסמכי התיעוד של הספרייה כדי לראות את התחביר של הביטויים הרגולריים.
REPEAT(string, integer) REPEAT(string, integer)
REPLACE(string, old_chars, new_chars) REPLACE(string, old_chars, new_chars)
REPLICA(string, integer) REPEAT(string, integer)
REVERSE(expression) REVERSE(expression)
RTRIM(string, trim_chars) RTRIM(string, trim_chars)
SPLIT_PART(string, delimiter, part) SPLIT(
string
delimiter
)SAFE_ORDINAL(part)
STRPOS(string, substring) STRPOS(string, substring)
STRTOL(string, base)
SUBSTRING(
string,
start_position, number_characters ) 		SUBSTR(
string,
start_position, number_characters )
TEXTLEN(expression) LENGTH(expression)
TRANSLATE(
expression,
characters_to_replace, characters_to_substitute ) 		אפשר להטמיע את הפונקציה באמצעות UDF:

CREATE TEMP FUNCTION
translate(expression STRING,
characters_to_replace STRING, characters_to_substitute STRING) AS ( IF(LENGTH(characters_to_replace) < LENGTH(characters_to_substitute) OR LENGTH(expression) <
LENGTH(characters_to_replace), expression,
(SELECT
STRING_AGG(
IFNULL(
(SELECT ARRAY_CONCAT([c],
SPLIT(characters_to_substitute, ''))[SAFE_OFFSET((
SELECT IFNULL(MIN(o2) + 1,
0) FROM
UNNEST(SPLIT(characters_to_replace,
'')) AS k WITH OFFSET o2
WHERE k = c))]
),
''),
'' ORDER BY o1)
FROM UNNEST(SPLIT(expression, ''))
AS c WITH OFFSET o1
))
);
TRIM([BOTH] string) TRIM(string)
TRIM([BOTH] characters FROM string) TRIM(string, characters)
UPPER(string) UPPER(string)

פונקציות לעיצוב סוגי נתונים

‫Amazon Redshift BigQuery
CAST(expression AS type) CAST(expression AS type)
expression :: type CAST(expression AS type)
CONVERT(type, expression) CAST(expression AS type)
TO_CHAR(
timestamp_expression, format
)		 FORMAT_TIMESTAMP(
format,
timestamp_expression
)

הערה: יש הבדל בין BigQuery לבין Amazon Redshift באופן שבו מציינים מחרוזת פורמט עבור timestamp_expression.
TO_CHAR(
numeric_expression,
format
)		 FORMAT(
format,
numeric_expression
)

הערה: יש הבדל בין BigQuery לבין Amazon Redshift באופן שבו מציינים מחרוזת פורמט עבור timestamp_expression.
TO_DATE(date_string, format) PARSE_DATE(date_string, format)

הערה: יש הבדל בין BigQuery לבין Amazon Redshift באופן שבו מציינים מחרוזת פורמט עבור date_string.
TO_NUMBER(string, format) CAST(
FORMAT(
format,
numeric_expression
) TO INT64
)

הערה: יש הבדל בין BigQuery לבין Amazon Redshift באופן שבו מציינים מחרוזת פורמט מספרי.

‫BigQuery תומך גם ב-SAFE_CAST(expression AS typename), שמחזירה NULL אם BigQuery לא מצליח לבצע המרה. לדוגמה, SAFE_CAST("apple" AS INT64) מחזירה NULL.

תחביר DML

בקטע הזה מוסבר על ההבדלים בתחביר של שפת ניהול הנתונים בין Amazon Redshift לבין BigQuery.

INSERT דוחות

‫Amazon Redshift מציע מילת מפתח DEFAULT שניתנת להגדרה לעמודות. ב-BigQuery, הערך DEFAULT לעמודות שאפשר להשאיר ריקות הוא NULL, והערך DEFAULT לא נתמך בעמודות חובה. רוב ההצהרות של Amazon Redshift INSERT תואמות ל-BigQuery. בטבלה הבאה מוצגים יוצאים מן הכלל.

‫Amazon Redshift BigQuery
INSERT INTO table (column1 [, ...])
DEFAULT VALUES		 INSERT [INTO] table (column1 [, ...])
VALUES (DEFAULT [, ...])
INSERT INTO table (column1, [,...]) VALUES (
SELECT ...
FROM ...
)		 INSERT [INTO] table (column1, [,...])
SELECT ...
FROM ...

ב-BigQuery יש גם תמיכה בהוספת ערכים באמצעות שאילתת משנה (כאשר אחד מהערכים מחושב באמצעות שאילתת משנה), אבל אין תמיכה כזו ב-Amazon Redshift. לדוגמה:

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

COPY דוחות

הפקודה COPY של Amazon Redshift טוענת נתונים לטבלה מקובצי נתונים או מטבלה של Amazon DynamoDB. ‫BigQuery לא משתמש בפקודה SQL COPY כדי לטעון נתונים, אבל אפשר להשתמש בכלים ובאפשרויות שונות שאינם מבוססי SQL כדי לטעון נתונים לטבלאות BigQuery. אפשר גם להשתמש ב-sink-ים של פייפליין נתונים שזמינים ב-Apache Spark או ב-Apache Beam כדי לכתוב נתונים ב-BigQuery.

UPDATE דוחות

רוב ההצהרות של Amazon Redshift UPDATE תואמות ל-BigQuery. בטבלה הבאה מוצגים יוצאים מן הכלל.

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

הערה: כל הצהרות UPDATE ב-BigQuery דורשות מילת מפתח WHERE, ואחריה תנאי.
UPDATE table
SET column = DEFAULT [,...] [FROM ...]
[WHERE ...]		 UPDATE table
SET column = NULL [, ...]
[FROM ...]
WHERE ...

הערה: הפקודה UPDATE של BigQuery לא תומכת בערכים DEFAULT.

אם הצהרת UPDATE של Amazon Redshift לא כוללת פסקה של WHERE, צריך להגדיר תנאי להצהרת UPDATE של BigQuery WHERE TRUE.

DELETE ודוחות TRUNCATE

הפקודות DELETE ו-TRUNCATE הן שתי דרכים להסרת שורות מטבלה בלי להשפיע על סכימת הטבלה או על האינדקסים.

ב-Amazon Redshift, מומלץ להשתמש בהצהרת TRUNCATE במקום בהצהרת DELETE לא מוגדרת, כי היא מהירה יותר ולא נדרשות פעולות VACUUM ו-ANALYZE אחריה. אבל אפשר להשתמש בהצהרות DELETE כדי להשיג את אותה ההשפעה.

ב-BigQuery, להצהרת DELETE חייב להיות סעיף WHERE. מידע נוסף על DELETE ב-BigQuery זמין בדוגמאות לשימוש ב-DELETE ב-BigQuery במאמרי העזרה בנושא DML.

‫Amazon Redshift BigQuery
DELETE [FROM] table_name

TRUNCATE [TABLE] table_name		 DELETE FROM table_name
WHERE TRUE

הצהרות של BigQuery DELETE מחייבות שימוש בסעיף WHERE.
DELETE FROM table_name
USING other_table
WHERE table_name.id=other_table.id		 DELETE FROM table_name
WHERE table_name.id IN (
SELECT id
FROM other_table
)

DELETE FROM table_name
WHERE EXISTS (
SELECT id
FROM other_table
WHERE table_name.id = other_table.id )

ב-Amazon Redshift, ‏ USING מאפשר להפנות לטבלאות נוספות בסעיף WHERE. אפשר לעשות את זה ב-BigQuery באמצעות שאילתת משנה בסעיף WHERE.

MERGE דוחות

אפשר לשלב את הפעולות INSERT, UPDATE ו-DELETE בהצהרת MERGE אחת של עדכון או הוספה, ולבצע את הפעולות באופן אטומי. MERGE הפעולה צריכה להתאים לשורת מקור אחת לכל היותר עבור כל שורת יעד.

‫Amazon Redshift לא תומך בפקודה יחידה של MERGE. עם זאת, אפשר לבצע פעולת מיזוג ב-Amazon Redshift על ידי ביצוע הפעולות INSERT, UPDATE ו-DELETE בעסקה.

מיזוג פעולה על ידי החלפת השורות הקיימות

ב-Amazon Redshift, אפשר להחליף את כל העמודות בטבלת היעד באמצעות הצהרת DELETE ואז הצהרת INSERT. ההצהרה DELETE מסירה שורות שצריך לעדכן, ואז ההצהרה INSERT מוסיפה את השורות המעודכנות. ההגבלה על טבלאות ב-BigQuery היא 1,000 הצהרות DML ביום, ולכן כדאי לאחד את ההצהרות INSERT, UPDATE ו-DELETE להצהרת MERGE אחת, כמו שמוצג בטבלה הבאה.

‫Amazon Redshift BigQuery
מידע נוסף זמין במאמר בנושא ביצוע פעולת מיזוג על ידי החלפת שורות קיימות.

CREATE TEMP TABLE temp_table;

INSERT INTO temp_table
SELECT *
FROM source
WHERE source.filter = 'filter_exp';

BEGIN TRANSACTION;

DELETE FROM target
USING temp_table
WHERE target.key = temp_table.key;

INSERT INTO target
SELECT *
FROM temp_table;

END TRANSACTION;

DROP TABLE temp_table; 		MERGE target
USING source
ON target.key = source.key
WHEN MATCHED AND source.filter = 'filter_exp' THEN
UPDATE SET
target.col1 = source.col1,
target.col2 = source.col2,
...

הערה: אם מעדכנים את כל העמודות, צריך לכלול את כולן.
ביצוע פעולת מיזוג על ידי ציון רשימת עמודות

CREATE TEMP TABLE temp_table;

INSERT INTO temp_table
SELECT *
FROM source
WHERE source.filter = 'filter_exp';

BEGIN TRANSACTION;

UPDATE target SET
col1 = temp_table.col1,
col2 = temp_table.col2
FROM temp_table
WHERE target.key=temp_table.key;

INSERT INTO target
SELECT *
FROM 		MERGE target
USING source
ON target.key = source.key
WHEN MATCHED AND source.filter = 'filter_exp' THEN
UPDATE SET
target.col1 = source.col1,
target.col2 = source.col2

תחביר DDL

בקטע הזה מוסברים ההבדלים בתחביר של שפת הגדרת הנתונים בין Amazon Redshift לבין BigQuery.

SELECT INTO דוחות

ב-Amazon Redshift, אפשר להשתמש בהצהרה SELECT INTO כדי להוסיף את התוצאות של שאילתה לטבלה חדשה, ולשלב בין יצירת הטבלה לבין הוספת הנתונים.

‫Amazon Redshift BigQuery
SELECT expression, ... INTO table
FROM ... 		INSERT table
SELECT expression, ...
FROM ...
WITH subquery_table AS ( SELECT ...
)
SELECT expression, ... INTO table
FROM subquery_table
... 		INSERT table
WITH subquery_table AS (
SELECT ...
)
SELECT expression, ...
FROM subquery_table
...
SELECT expression
INTO TEMP table
FROM ...

SELECT expression
INTO TEMPORARY table
FROM ... 		ב-BigQuery יש כמה דרכים לדמות טבלאות זמניות. מידע נוסף זמין בקטע בנושא טבלאות זמניות.

CREATE TABLE דוחות

רוב ההצהרות של Amazon Redshift CREATE TABLE תואמות ל-BigQuery, למעט רכיבי התחביר הבאים שלא נמצאים בשימוש ב-BigQuery:

‫Amazon Redshift BigQuery
CREATE TABLE table_name (
col1 data_type1 NOT NULL,
col2 data_type2 NULL,
col3 data_type3 UNIQUE,
col4 data_type4 PRIMARY KEY,
col5 data_type5
)

הערה: המגבלות UNIQUE ו-PRIMARY KEY הן למידע בלבד, ולא נאכפות על ידי מערכת Amazon Redshift.		 CREATE TABLE table_name (
col1 data_type1 NOT NULL,
col2 data_type2,
col3 data_type3,
col4 data_type4,
col5 data_type5,
)
CREATE TABLE table_name
(
col1 data_type1[,...]
table_constraints
)
where table_constraints are:
[UNIQUE(column_name [, ... ])]
[PRIMARY KEY(column_name [, ...])]
[FOREIGN KEY(column_name [, ...])
REFERENCES reftable [(refcolumn)]

הערה: המגבלות UNIQUE ו-PRIMARY KEY הן אינפורמטיביות ולא נאכפות על ידי מערכת Amazon Redshift. 		CREATE TABLE table_name
(
col1 data_type1[,...]
)
PARTITION BY column_name
CLUSTER BY column_name [, ...]

הערה: ב-BigQuery לא נעשה שימוש באילוצי טבלה UNIQUE, PRIMARY KEY או FOREIGN KEY. כדי להשיג אופטימיזציה דומה לזו שמספקות המגבלות האלה במהלך ביצוע השאילתה, צריך לבצע חלוקה למחיצות (partitioning) ואשכול (clustering) של טבלאות BigQuery. ‫CLUSTER BY תומך בעד 4 עמודות.
CREATE TABLE table_name
LIKE original_table_name 		בדוגמה הזו מוסבר איך להשתמש בטבלאות INFORMATION_SCHEMA כדי להעתיק שמות של עמודות, סוגי נתונים ואילוצי NOT NULL לטבלה חדשה.
CREATE TABLE table_name
(
col1 data_type1
)
BACKUP NO

הערה: ב-Amazon Redshift, ההגדרה BACKUP NO מצוינת כדי לחסוך זמן עיבוד ולצמצם את נפח האחסון.		 לא נעשה שימוש באפשרות הטבלה BACKUP NO, כי BigQuery שומר באופן אוטומטי עד 7 ימים של גרסאות היסטוריות של כל הטבלאות, בלי להשפיע על זמן העיבוד או על נפח האחסון שמחויב.
CREATE TABLE table_name
(
col1 data_type1
)
table_attributes
where table_attributes are:
[DISTSTYLE {AUTO|EVEN|KEY|ALL}]
[DISTKEY (column_name)]
[[COMPOUND|INTERLEAVED] SORTKEY
(column_name [, ...])] 		‫BigQuery תומך ביצירת אשכולות, שמאפשרת לאחסן מפתחות בסדר ממוין.
CREATE TABLE table_name
AS SELECT ... 		CREATE TABLE table_name
AS SELECT ...
CREATE TABLE IF NOT EXISTS table_name ... CREATE TABLE IF NOT EXISTS
table_name
...

ב-BigQuery יש גם תמיכה בהצהרת DDL‏ CREATE OR REPLACE TABLE, שדורסת טבלה אם היא כבר קיימת.

ההצהרה CREATE TABLE של BigQuery תומכת גם בסעיפים הבאים, שאין להם מקבילה ב-Amazon Redshift:

מידע נוסף על CREATE TABLE ב-BigQuery זמין בדוגמאות לשימוש ב-CREATE TABLE ב-BigQuery, במאמר בנושא DML.

טבלאות זמניות

‫Amazon Redshift תומך בטבלאות זמניות, שגלויות רק במהלך הסשן הנוכחי. יש כמה דרכים לדמות טבלאות זמניות ב-BigQuery:

  • אורך החיים של מערך הנתונים: יוצרים מערך נתונים עם אורך חיים קצר (לדוגמה, שעה אחת), כך שכל הטבלאות שנוצרות במערך הנתונים הן למעשה זמניות כי הן לא יישמרו מעבר לאורך החיים של מערך הנתונים. אפשר להוסיף את הקידומת temp לכל שמות הטבלאות במערך הנתונים הזה כדי לציין בבירור שהטבלאות הן זמניות.

  • ‫TTL של טבלה: יוצרים טבלה עם זמן חיים קצר וספציפי לטבלה באמצעות הצהרות DDL שדומות להצהרות הבאות:

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

CREATE VIEW דוחות

בטבלה הבאה מוצגים מקבילים בין Amazon Redshift לבין BigQuery עבור ההצהרה CREATE VIEW.

‫Amazon Redshift BigQuery
CREATE VIEW view_name AS SELECT ...code> CREATE VIEW view_name AS SELECT ...
CREATE OR REPLACE VIEW view_name AS SELECT ... CREATE OR REPLACE VIEW
view_name AS
SELECT ...
CREATE VIEW view_name
(column_name, ...)
AS SELECT ... 		CREATE VIEW view_name AS SELECT ...
לא נתמך. CREATE VIEW IF NOT EXISTS c view_name
OPTIONS(view_option_list)
AS SELECT …

יוצר תצוגה חדשה רק אם התצוגה לא קיימת במערך הנתונים שצוין.
CREATE VIEW view_name
AS SELECT ...
WITH NO SCHEMA BINDING

ב-Amazon Redshift, נדרשת תצוגה של late binding כדי להפנות לטבלה חיצונית.		 כדי ליצור תצוגה ב-BigQuery, כל האובייקטים שמופיעה אליהם הפניה צריכים כבר להתקיים.

ב-BigQuery אפשר להריץ שאילתות על מקורות נתונים חיצוניים.

פונקציות בהגדרת המשתמש (UDF)

פונקציה בהגדרת המשתמש (UDF) מאפשרת ליצור פונקציות לפעולות בהתאמה אישית. הפונקציות האלה מקבלות עמודות קלט, מבצעות פעולות ומחזירות את התוצאה של הפעולות האלה בתור ערך.

גם Amazon Redshift וגם BigQuery תומכים בפונקציות UDF באמצעות ביטויי SQL. בנוסף, ב-Amazon Redshift אפשר ליצור UDF מבוסס Python, וב-BigQuery אפשר ליצור UDF מבוסס JavaScript.

במאגר כלי השירות של Google Cloud BigQuery ב-GitHub אפשר למצוא ספרייה של פונקציות נפוצות מוגדרות על ידי המשתמש (UDF) ב-BigQuery.

תחביר CREATE FUNCTION

בטבלה הבאה מפורטים ההבדלים בתחביר של יצירת פונקציות מוגדרות על ידי המשתמש (UDF) ב-SQL בין Amazon Redshift לבין 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

הערה: ב-SQL UDF ב-BigQuery, סוג הנתונים שמוחזר הוא אופציונלי. מערכת BigQuery מסיקה את סוג התוצאה של הפונקציה מגוף פונקציית ה-SQL כששאילתה קוראת לפונקציה.
CREATE [OR REPLACE] FUNCTION
function_name
([sql_arg_name sql_arg_data_type[,..]]) RETURNS data_type
{ VOLATILE | STABLE | IMMUTABLE } AS $$
sql_function_definition
$$ LANGUAGE sql 		CREATE [OR REPLACE] FUNCTION
function_name
([sql_arg_name sql_arg_data_type[,..]]) RETURNS data_type
AS sql_function_definition

הערה: התנודתיות של הפונקציה היא לא פרמטר שאפשר להגדיר ב-BigQuery. כל התנודתיות של UDF ב-BigQuery שווה לתנודתיות של IMMUTABLE ב-Amazon Redshift (כלומר, היא לא מבצעת חיפושים במסד הנתונים או משתמשת במידע שלא מופיע ישירות ברשימת הארגומנטים שלה).
CREATE [OR REPLACE] FUNCTION
function_name
([sql_arg_name sql_arg_data_type[,..]]) RETURNS data_type
IMMUTABLE
AS $$
SELECT_clause
$$ LANGUAGE sql

הערה: ב-Amazon Redshift אפשר להשתמש רק בסעיף SQL SELECT כהגדרת פונקציה. בנוסף, סעיף SELECT לא יכול לכלול את הסעיפים FROM, INTO, WHERE, GROUP BY, ORDER BY, ו-LIMIT. 		CREATE [OR REPLACE] FUNCTION
function_name
([sql_arg_name sql_arg_data_type[,..]]) RETURNS data_type
AS sql_expression

הערה: BigQuery תומך בכל ביטויי SQL כהגדרת פונקציה. עם זאת, הפניה לטבלאות, לתצוגות או למודלים אינה נתמכת.
CREATE [OR REPLACE] FUNCTION
function_name
([sql_arg_name sql_arg_data_type[,..]]) RETURNS data_type
IMMUTABLE
AS $$
sql_function_definition
$$ LANGUAGE sql 		CREATE [OR REPLACE] FUNCTION function_name ([sql_arg_name sql_arg_data_type[,..]]) RETURNS data_type AS sql_function_definition

הערה: אין צורך לציין את השפה המילולית ב-UDF של GoogleSQL. כברירת מחדל, BigQuery מפרש את ביטוי ה-SQL. בנוסף, נעשה שימוש בסימן הדולר ($$) is not supported in BigQuery.
CREATE [OR REPLACE] FUNCTION function_name (integer, integer) RETURNS integer IMMUTABLE AS $$ SELECT $1 + $2 $$ LANGUAGE sql CREATE [OR REPLACE] FUNCTION
function_name
(x INT64, y INT64)
RETURNS INT64
AS
SELECT x + y

Note: BigQuery UDFs require all input arguments to be named. The Amazon Redshift argument variables ($1, $2, …) are not supported in BigQuery.
CREATE [OR REPLACE] FUNCTION
function_name
(integer, integer)
RETURNS integer
IMMUTABLE
AS $$
SELECT $1 + $2
$$ LANGUAGE sql

Note: Amazon Redshift does not support ANY TYPE for SQL UDFs. However, it supports using the ANYELEMENT data type in Python-based UDFs. 		CREATE [OR REPLACE] FUNCTION
function_name
(x ANY TYPE, y ANY TYPE)
AS
SELECT x + y

Note: BigQuery supports using ANY TYPE as argument type. The function accepts an input of any type for this argument. For more information, see templated parameter in BigQuery.

BigQuery also supports the CREATE FUNCTION IF NOT EXISTS statement, which treats the query as successful and takes no action if a function with the same name already exists.

BigQuery's CREATE FUNCTION statement also supports creating TEMPORARY or TEMP functions, which do not have an Amazon Redshift equivalent.

See calling UDFs for details on executing a BigQuery-persistent UDF.

DROP FUNCTION syntax

The following table addresses differences in DROP FUNCTION syntax between Amazon Redshift and BigQuery.

Amazon Redshift BigQuery
DROP FUNCTION
function_name
( [arg_name] arg_type [, ...] ) [ CASCADE | RESTRICT ]		 DROP FUNCTION
dataset_name.function_name

Note: BigQuery does not require using the function's signature for deleting the function. Also, removing function dependencies is not supported in BigQuery.

BigQuery also supports the DROP FUNCTION IF EXISTS statement, which deletes the function only if the function exists in the specified dataset.

BigQuery requires that you specify the project_name if the function is not located in the current project.

UDF components

This section highlights the similarities and differences in UDF components between Amazon Redshift andBigQuery.

Component Amazon Redshift BigQuery
Name Amazon Redshift recommends using the prefix _f for function names to avoid conflicts with existing or future built-in SQL function names. In BigQuery, you can use any custom function name.
Arguments Arguments are optional. You can use name and data types for Python UDF arguments and only data types for SQL UDF arguments. In SQL UDFs, you must refer to arguments using $1, $2, and so on. Amazon Redshift also restricts the number of arguments to 32. Arguments are optional, but if you specify arguments, they must use both name and data types for both JavaScript and SQL UDFs. The maximum number of arguments for a persistent UDF is 256.
Data type Amazon Redshift supports a different set of data types for SQL and Python UDFs.
For a Python UDF, the data type might also be ANYELEMENT.

You must specify a RETURN data type for both SQL and Python UDFs.

See Data types in this document for equivalents between data types in Amazon Redshift and in BigQuery.		 BigQuery supports a different set of data types for SQL and JavaScript UDFs.
For a SQL UDF, the data type might also be ANY TYPE. For more information, see templated parameters in BigQuery.

The RETURN data type is optional for SQL UDFs.

See Supported JavaScript UDF data types for information on how BigQuery data types map to JavaScript data types.
Definition For both SQL and Python UDFs, you must enclose the function definition using dollar quoting, as in a pair of dollar signs ($$) של Amazon Redshift כדי לציין את ההתחלה והסוף של הצהרות הפונקציה.

ב-SQL UDFs,‏ Amazon Redshift תומך רק ב-SQL SELECT clause כהגדרת הפונקציה. בנוסף, סעיף SELECT לא יכול לכלול אף אחד מהסעיפים FROM, INTO, WHERE, GROUP
, BY, ORDER BY ו-LIMIT .‫

במקרה של UDF של Python, אפשר לכתוב תוכנת Python באמצעות הספרייה הרגילה של Python 2.7 או לייבא מודולים בהתאמה אישית על ידי יצירת מודול באמצעות הפקודה CREATE LIBRARY .		 ב-BigQuery, צריך להוסיף מרכאות לקוד ה-JavaScript. מידע נוסף זמין בכללים בנושא ציטוט.

בפונקציות SQL בהגדרת המשתמש, אפשר להשתמש בכל ביטויי SQL כהגדרת הפונקציה. עם זאת, ב-BigQuery אין תמיכה בהפניה לטבלאות, לתצוגות או למודלים.

במקרה של פונקציות מוגדרות על ידי המשתמש ב-JavaScript, אפשר לכלול ספריות קוד חיצוניות ישירות באמצעות הקטע OPTIONS . אפשר גם להשתמש בכלי לבדיקת פונקציות מוגדרות על ידי המשתמש (UDF) ב-BigQuery כדי לבדוק את הפונקציות.
שפה צריך להשתמש בLANGUAGE literal כדי לציין את השפה כ-sql עבור פונקציות UDF של SQL או כ-plpythonu עבור פונקציות UDF של Python. אין צורך לציין LANGUAGE עבור פונקציות SQL UDF, אבל צריך לציין את השפה כ-js עבור פונקציות JavaScript UDF.
מדינה ‫Amazon Redshift לא תומך ביצירת פונקציות זמניות מוגדרות על ידי המשתמש (UDF).

ב-Amazon Redshift יש אפשרות להגדיר את התנודתיות של פונקציה באמצעות הערכים VOLATILE, STABLE או IMMUTABLE . האופטימיזציה מבוצעת על ידי הכלי לאופטימיזציה של שאילתות.		 ‫BigQuery תומך בפונקציות UDF קבועות וזמניות. אפשר להשתמש שוב בפונקציות UDF מתמידות בכמה שאילתות, ופונקציית UDF זמנית קיימת רק בהיקף של שאילתה אחת.

התנודתיות של הפונקציה היא לא פרמטר שאפשר להגדיר ב-BigQuery. כל התנודתיות של פונקציות UDF ב-BigQuery שווה לתנודתיות של IMMUTABLE פונקציות UDF ב-Amazon Redshift.
אבטחה והרשאות כדי ליצור UDF, צריכה להיות לכם הרשאה לשימוש בשפה עבור SQL או plpythonu (Python). כברירת מחדל, ההרשאה USAGE ON LANGUAGE SQL מוענקת ל-PUBLIC, אבל צריך להעניק את ההרשאה USAGE ON LANGUAGE PLPYTHONU באופן מפורש למשתמשים או לקבוצות ספציפיים.
בנוסף, צריך להיות משתמש על כדי להחליף UDF.		 ב-BigQuery, אין צורך להעניק הרשאות מפורשות ליצירה או למחיקה של פונקציות מוגדרות על ידי המשתמש (UDF) מכל סוג. כל משתמש שהוקצה לו התפקיד BigQuery Data Editor (עם bigquery.routines.* כאחת ההרשאות) יכול ליצור או למחוק פונקציות עבור מערך הנתונים שצוין.

ב-BigQuery אפשר גם ליצור תפקידים בהתאמה אישית. אפשר לנהל את זה באמצעות Cloud IAM.
מגבלות מידע נוסף זמין במאמר בנושא מגבלות של פונקציות מוגדרות על ידי המשתמש ב-Python. מגבלות על פונקציות שמוגדרות על ידי המשתמש

מטא-נתונים והצהרות SQL של טרנזקציות

‫Amazon Redshift BigQuery
SELECT * FROM STL_ANALYZE WHERE name
= 'T';		 לא בשימוש ב-BigQuery. לא צריך לאסוף נתונים סטטיסטיים כדי לשפר את ביצועי השאילתות. כדי לקבל מידע על פיזור הנתונים, אפשר להשתמש בפונקציות מצטברות משוערות.
ANALYZE [[ table_name[(column_name
[, ...])]]		 לא בשימוש ב-BigQuery.
LOCK TABLE table_name; לא בשימוש ב-BigQuery.
BEGIN TRANSACTION; SELECT ...
END TRANSACTION;		 ב-BigQuery נעשה שימוש בבידוד snapshot. פרטים נוספים זמינים במאמר בנושא עקביות.
EXPLAIN ... לא בשימוש ב-BigQuery.

תכונות דומות הן הסבר על תוכנית השאילתות במסוף BigQuery Google Cloud , ורישום ביומן ביקורת ב-Cloud Monitoring.
SELECT * FROM SVV_TABLE_INFO WHERE
table = 'T';		 SELECT * EXCEPT(is_typed) FROM
mydataset.INFORMATION_SCHEMA.TABLES;

מידע נוסף זמין במאמר מבוא ל-BigQuery INFORMATION_SCHEMA.
VACUUM [table_name] לא בשימוש ב-BigQuery. הטבלאות המאוגדות ב-BigQuery ממוינות באופן אוטומטי.

הצהרות SQL מרובות שורות והצהרות SQL מרובות

גם Amazon Redshift וגם BigQuery תומכים בטרנזקציות (סשנים), ולכן תומכים בהצהרות שמופרדות באמצעות נקודה ופסיק, שמופעלות יחד באופן עקבי. מידע נוסף מופיע במאמר בנושא טרנזקציות עם כמה תדפיסי חשבון.

הצהרות SQL פרוצדורליות

CREATE PROCEDURE דוחות

‫Amazon Redshift BigQuery
CREATE or REPLACE PROCEDURE CREATE PROCEDURE אם נדרש שם.

אחרת, משתמשים ב-inline עם BEGIN או בשורה אחת עם CREATE TEMP FUNCTION.
CALL CALL

הצהרה על משתנה והקצאת ערך

‫Amazon Redshift BigQuery
DECLARE DECLARE

מגדיר משתנה מהסוג שצוין.
SET SET

הפונקציה הזו מגדירה משתנה עם הערך של הביטוי שצוין, או מגדירה כמה משתנים בו-זמנית על סמך התוצאה של כמה ביטויים.

מטפלים בתנאי שגיאה

ב-Amazon Redshift, שגיאה שמתרחשת במהלך הביצוע של פרוצדורה מאוחסנת מסיימת את זרימת הביצוע, מסיימת את העסקה ומבטלת את העסקה. התוצאות האלה מתקבלות כי אין תמיכה בעסקאות משנה. בתהליך מאוחסן ב-Amazon Redshift, רק handler_statement נתמך, והוא RAISE. ב-BigQuery, טיפול בשגיאות הוא התכונה העיקרית של זרימת הבקרה הראשית, בדומה למה ששפות אחרות מספקות עם בלוקים של TRY ... CATCH.

‫Amazon Redshift BigQuery
BEGIN ... EXCEPTION WHEN OTHERS THEN BEGIN ... EXCEPTION WHEN ERROR THEN
RAISE RAISE
[ <<label>> ] [ DECLARE declarations ]
BEGIN
statements EXCEPTION
BEGIN
statements
EXCEPTION
WHEN OTHERS THEN
Handler_statements
END;		 BEGIN
BEGIN
...
EXCEPTION WHEN ERROR THEN SELECT 1/0;
END;

EXCEPTION WHEN ERROR THEN -- The exception thrown from the inner exception handler lands here. END;

הצהרות ופעולות של סמן

מכיוון ש-BigQuery לא תומך בסמני מיקום או בסשנים, לא נעשה שימוש בהצהרות הבאות ב-BigQuery:

אם אתם משתמשים בסמן כדי להחזיר קבוצת תוצאות, תוכלו להשיג התנהגות דומה באמצעות טבלאות זמניות ב-BigQuery.

הצהרות SQL דינמיות

התכונה 'סקריפטים' ב-BigQuery תומכת בהצהרות SQL דינמיות כמו אלה שמוצגות בטבלה הבאה.

‫Amazon Redshift BigQuery
EXECUTE EXECUTE IMMEDIATE

משפטי בקרה

‫Amazon Redshift BigQuery
IF..THEN..ELSIF..THEN..ELSE..END IF IF condition
THEN stmts
ELSE stmts
END IF
name CURSOR [ ( arguments ) ] FOR query ב-BigQuery לא נעשה שימוש בסמני מיקום או בסשנים.
[< LOOP
sql_statement_list END LOOP;
WHILE condition LOOP stmts END LOOP WHILE condition
DO stmts
END WHILE
EXIT BREAK

התחייבויות עקביות ורמת בידוד של טרנזקציה

גם Amazon Redshift וגם BigQuery הן אטומיות – כלומר, הן תואמות ל-ACID ברמת כל שינוי בהרבה שורות.

טרנזקציות

‫Amazon Redshift תומך בבידוד ניתן לסדר כברירת מחדל לעסקאות. ב-Amazon Redshift אפשר לציין כל אחת מארבע רמות הבידוד של טרנזקציות בתקן SQL, אבל המערכת מעבדת את כל רמות הבידוד כניתנות לסדרות.

‫BigQuery גם תומך בעסקאות. ‫BigQuery עוזר להבטיח בקרת בו-זמניות אופטימית (למי ששולח את השינויים ראשון יש עדיפות) עם בידוד snapshot , שבו שאילתה קוראת את הנתונים האחרונים שנשמרו לפני שהיא מתחילה. הגישה הזו מבטיחה את אותה רמת עקביות ברמת השורה, ברמת השינוי ובשורות שונות באותה פקודת DML, ועדיין מונעת מצבים של חסימה הדדית. במקרה של כמה עדכוני DML באותה טבלה, BigQuery עובר לבקרת בו-זמניות פסימית. אפשר להריץ משימות טעינה באופן עצמאי לחלוטין ולצרף אותן לטבלאות.

חזרה לגרסה קודמת

אם Amazon Redshift נתקל בשגיאה כלשהי במהלך הפעלת פרוצדורה מאוחסנת, הוא מבטל את כל השינויים שבוצעו בעסקה. בנוסף, אפשר להשתמש במשפט הבקרה של העסקה ROLLBACK בהליך מאוחסן כדי לבטל את כל השינויים.

ב-BigQuery, אפשר להשתמש בהצהרה ROLLBACK TRANSACTION.

מגבלות על מסדי נתונים

כדאי לעיין במסמכים הציבוריים של BigQuery כדי לראות את המכסות והמגבלות העדכניות. משתמשים עם נפח גדול יכולים לפנות לצוות התמיכה ב-Cloud כדי להגדיל את המכסות שלהם. בטבלה הבאה מוצגת השוואה בין מגבלות מסד הנתונים של Amazon Redshift ושל BigQuery.

מגבלה ‫Amazon Redshift BigQuery
טבלאות בכל מסד נתונים עבור סוגי צמתים של אשכולות גדולים וגדולים במיוחד 9,900 לא מוגבל
טבלאות בכל מסד נתונים לסוגי צמתים של אשכולים בגודל 8xlarge 20,000 לא מוגבל
מסדי נתונים שמוגדרים על ידי המשתמש שאפשר ליצור לכל אשכול 60 לא מוגבל
גודל שורה מקסימלי ‫4MB ‫100MB