מדריך לתרגום Oracle SQL

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

סוגי נתונים

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

Oracle	BigQuery	הערות
`VARCHAR2`	`STRING`
`NVARCHAR2`	`STRING`
`CHAR`	`STRING`
`NCHAR`	`STRING`
`CLOB`	`STRING`
`NCLOB`	`STRING`
`INTEGER`	`INT64`
`SHORTINTEGER`	`INT64`
`LONGINTEGER`	`INT64`
`NUMBER`	`NUMERIC`	ב-BigQuery אי אפשר להגדיר ערכים מותאמים אישית לדיוק או לקנה מידה. כתוצאה מכך, יכול להיות שעמודה ב-Oracle מוגדרת עם קנה מידה גדול יותר ממה ש-BigQuery תומך בו. בנוסף, לפני שמירת מספר עשרוני, מערכת Oracle מעגלת אותו כלפי מעלה אם יש לו יותר ספרות אחרי הנקודה העשרונית ממה שצוין עבור העמודה המתאימה. ב-BigQuery, אפשר להטמיע את התכונה הזו באמצעות הפונקציה `ROUND()`.
`NUMBER(*, x)`	`NUMERIC`	ב-BigQuery אי אפשר להגדיר ערכים מותאמים אישית לדיוק או לקנה מידה. כתוצאה מכך, יכול להיות שעמודה ב-Oracle מוגדרת עם קנה מידה גדול יותר ממה ש-BigQuery תומך בו. בנוסף, לפני שמירת מספר עשרוני, מערכת Oracle מעגלת אותו כלפי מעלה אם יש לו יותר ספרות אחרי הנקודה העשרונית ממה שצוין עבור העמודה המתאימה. ב-BigQuery, אפשר להטמיע את התכונה הזו באמצעות הפונקציה `ROUND()`.
`NUMBER(x, -y)`	`INT64`	אם משתמש מנסה לאחסן מספר עשרוני, Oracle מעגלת אותו למספר שלם. ב-BigQuery, ניסיון לאחסן מספר עשרוני בעמודה שהוגדרה כ-`INT64` יוביל לשגיאה. במקרה כזה, צריך להשתמש בפונקציה `ROUND()`. סוגי הנתונים ב-BigQuery `INT64` מאפשרים עד 18 ספרות של דיוק. אם שדה מספר מכיל יותר מ-18 ספרות, צריך להשתמש בסוג הנתונים `FLOAT64` ב-BigQuery.
`NUMBER(x)`	`INT64`	אם משתמש מנסה לאחסן מספר עשרוני, Oracle מעגלת אותו למספר שלם. ב-BigQuery, ניסיון לאחסן מספר עשרוני בעמודה שהוגדרה כ-`INT64` יוביל לשגיאה. במקרה כזה, צריך להשתמש בפונקציה `ROUND()`. סוגי הנתונים ב-BigQuery `INT64` מאפשרים עד 18 ספרות של דיוק. אם שדה מספר מכיל יותר מ-18 ספרות, צריך להשתמש בסוג הנתונים `FLOAT64` ב-BigQuery.
`FLOAT`	`NUMERIC`/`FLOAT64`	‫`FLOAT` הוא סוג נתונים מדויק, והוא סוג משנה של `NUMBER` ב-Oracle. ב-BigQuery, ‏ `FLOAT64` הוא סוג נתונים משוער. יכול להיות שסוג הנתונים `NUMERIC` יתאים יותר לסוג הנתונים `FLOAT` ב-BigQuery.
`BINARY_DOUBLE`	`NUMERIC`/`FLOAT64`	‫`FLOAT` הוא סוג נתונים מדויק, והוא סוג משנה של `NUMBER` ב-Oracle. ב-BigQuery, ‏ `FLOAT64` הוא סוג נתונים משוער. יכול להיות שסוג הנתונים `NUMERIC` יתאים יותר לסוג הנתונים `FLOAT` ב-BigQuery.
`BINARY_FLOAT`	`NUMERIC`/`FLOAT64`	‫`FLOAT` הוא סוג נתונים מדויק, והוא סוג משנה של `NUMBER` ב-Oracle. ב-BigQuery, ‏ `FLOAT64` הוא סוג נתונים משוער. יכול להיות שסוג הנתונים `NUMERIC` יתאים יותר לסוג הנתונים `FLOAT` ב-BigQuery.
`LONG`	`BYTES`	סוג הנתונים `LONG` נמצא בשימוש בגרסאות קודמות, ולא מומלץ להשתמש בו בגרסאות חדשות של Oracle Database. אפשר להשתמש בסוג הנתונים `BYTES` ב-BigQuery אם צריך להחזיק נתונים מסוג `LONG` ב-BigQuery. גישה טובה יותר היא להציב אובייקטים בינאריים ב-Cloud Storage ולהחזיק הפניות ב-BigQuery.
`BLOB`	`BYTES`	אפשר להשתמש בסוג הנתונים `BYTES` כדי לאחסן נתונים בינאריים באורך משתנה. אם לא מבצעים שאילתות בשדה הזה ולא משתמשים בו בניתוחים, כדאי יותר לאחסן נתונים בינאריים ב-Cloud Storage.
`BFILE`	`STRING`	אפשר לאחסן קבצים בינאריים ב-Cloud Storage ולהשתמש בסוג הנתונים `STRING` כדי להפנות לקבצים בטבלה ב-BigQuery.
`DATE`	`DATETIME`
`TIMESTAMP`	`TIMESTAMP`	‫BigQuery תומך בדיוק של מיקרו-שנייה (10^-6) בהשוואה ל-Oracle, שתומך בדיוק בטווח של 0 עד 9. ‫BigQuery תומך בשם אזור זמן ממסד נתונים של TZ ובסטיית אזור זמן מ-UTC. ב-BigQuery, צריך לבצע המרה של אזור זמן באופן ידני כדי להתאים לתכונה `TIMESTAMP WITH LOCAL TIME ZONE` של Oracle.
`TIMESTAMP(x)`	`TIMESTAMP`	‫BigQuery תומך בדיוק של מיקרו-שנייה (10^-6) בהשוואה ל-Oracle, שתומך בדיוק בטווח של 0 עד 9. ‫BigQuery תומך בשם אזור זמן ממסד נתונים של TZ ובסטיית אזור זמן מ-UTC. ב-BigQuery, צריך לבצע המרה של אזור זמן באופן ידני כדי להתאים לתכונה `TIMESTAMP WITH LOCAL TIME ZONE` של Oracle.
`TIMESTAMP WITH TIME ZONE`	`TIMESTAMP`	‫BigQuery תומך בדיוק של מיקרו-שנייה (10^-6) בהשוואה ל-Oracle, שתומך בדיוק בטווח של 0 עד 9. ‫BigQuery תומך בשם אזור זמן ממסד נתונים של TZ ובסטיית אזור זמן מ-UTC. ב-BigQuery, צריך לבצע המרה של אזור זמן באופן ידני כדי להתאים לתכונה `TIMESTAMP WITH LOCAL TIME ZONE` של Oracle.
`TIMESTAMP WITH LOCAL TIME ZONE`	`TIMESTAMP`	‫BigQuery תומך בדיוק של מיקרו-שנייה (10^-6) בהשוואה ל-Oracle, שתומך בדיוק בטווח של 0 עד 9. ‫BigQuery תומך בשם אזור זמן ממסד נתונים של TZ ובסטיית אזור זמן מ-UTC. ב-BigQuery, צריך לבצע המרה של אזור זמן באופן ידני כדי להתאים לתכונה `TIMESTAMP WITH LOCAL TIME ZONE` של Oracle.
`INTERVAL YEAR TO MONTH`	`STRING`	אפשר לאחסן ערכי מרווח כסוג הנתונים `STRING` ב-BigQuery.
`INTERVAL DAY TO SECOND`	`STRING`	אפשר לאחסן ערכי מרווח כסוג הנתונים `STRING` ב-BigQuery.
`RAW`	`BYTES`	אפשר להשתמש בסוג הנתונים `BYTES` כדי לאחסן נתונים בינאריים באורך משתנה. אם לא מבצעים שאילתות בשדה הזה ולא משתמשים בו בניתוח, כדאי יותר לאחסן נתונים בינאריים ב-Cloud Storage.
`LONG RAW`	`BYTES`	אפשר להשתמש בסוג הנתונים `BYTES` כדי לאחסן נתונים בינאריים באורך משתנה. אם לא מבצעים שאילתות בשדה הזה ולא משתמשים בו בניתוח, כדאי יותר לאחסן נתונים בינאריים ב-Cloud Storage.
`ROWID`	`STRING`	סוגי הנתונים האלה משמשים את Oracle באופן פנימי כדי לציין כתובות ייחודיות לשורות בטבלה. באופן כללי, לא מומלץ להשתמש בשדות `ROWID` או `UROWID` באפליקציות. אבל אם זה המצב, אפשר להשתמש בסוג הנתונים `STRING` כדי לאחסן את הנתונים האלה.

עיצוב סוג

ב-Oracle SQL יש קבוצה של פורמטים שמוגדרים כפרמטרים להצגת ביטויים ונתוני עמודות, ולהמרות בין סוגי נתונים. לדוגמה, אם מגדירים את NLS_DATE_FORMAT כ-YYYY/MM/DD, התאריכים יוצגו כ-YYYY/MM/DD כברירת מחדל. מידע נוסף על הגדרות NLS זמין בתיעוד אונליין של Oracle. ב-BigQuery אין פרמטרים של אתחול.

כברירת מחדל, BigQuery מצפה שכל נתוני המקור יהיו בקידוד UTF-8 בזמן הטעינה. אם יש לכם קובצי CSV עם נתונים בקידוד ISO-8859-1, אתם יכולים לציין במפורש את הקידוד כשאתם מייבאים את הנתונים, כדי ש-BigQuery יוכל להמיר את הנתונים ל-UTF-8 במהלך תהליך הייבוא.

אפשר לייבא רק נתונים בקידוד ISO-8859-1 או UTF-8. מערכת BigQuery מאחסנת את הנתונים ומחזירה אותם בקידוד UTF-8. אפשר להגדיר את פורמט התאריך או אזור הזמן הרצויים בפונקציות DATE ו-TIMESTAMP.

עיצוב של חותמת זמן וסוג תאריך

כשממירים רכיבים של פורמט חותמת זמן ותאריך מ-Oracle ל-BigQuery, צריך לשים לב להבדלים באזורי הזמן בין TIMESTAMP לבין DATETIME, כפי שמסוכם בטבלה הבאה.

שימו לב שאין סוגריים בפורמטים של Oracle כי הפורמטים (CURRENT_*) הם מילות מפתח ולא פונקציות.

Oracle	BigQuery	הערות
`CURRENT_TIMESTAMP`	יכול להיות שפרטי `TIMESTAMP` ב-Oracle יכללו מידע שונה על אזור זמן, שמוגדר באמצעות `WITH TIME ZONE` בהגדרת העמודה או בהגדרת המשתנה `TIME_ZONE`.	אם אפשר, כדאי להשתמש בפונקציה `CURRENT_TIMESTAMP()` שמוגדרת בפורמט ISO. עם זאת, בפורמט הפלט תמיד מוצג אזור הזמן UTC. (מבחינה פנימית, ב-BigQuery אין אזור זמן). חשוב לשים לב לפרטים הבאים לגבי ההבדלים בפורמט ISO: `DATETIME` מפורמט בהתאם למוסכמות של ערוץ הפלט. בכלי שורת הפקודה של BigQuery ובמסוף BigQuery `DATETIME` מעוצב באמצעות מפריד `T` בהתאם ל-RFC 3339. עם זאת, ב-Python וב-Java JDBC, משתמשים ברווח כמפריד. אם רוצים להשתמש בפורמט מפורש, משתמשים בפונקציה `FORMAT_DATETIME`(), שמבצעת המרה מפורשת של מחרוזת. לדוגמה, הביטוי הבא תמיד מחזיר מפריד רווח: `CAST(CURRENT_DATETIME() AS STRING)`
`CURRENT_DATE SYSDATE`	‫Oracle משתמשת ב-2 סוגים של תאריכים: type 12 type 13 ‫Oracle משתמש בסוג 12 כשהוא מאחסן תאריכים. באופן פנימי, אלה מספרים באורך קבוע. ‫Oracle משתמש בסוג 13 כשמוחזר a על ידי `SYSDATE or CURRENT_DATE`	ב-BigQuery יש פורמט נפרד `DATE` שתמיד מחזיר תאריך בפורמט ISO 8601. אי אפשר להשתמש ב-`DATE_FROM_UNIX_DATE` כי הוא מבוסס על 1970.
`CURRENT_DATE-3`	ערכי תאריך מיוצגים כמספרים שלמים. ‫Oracle תומך באופרטורים אריתמטיים לסוגי תאריכים.	עבור סוגי תאריכים, משתמשים ב-`DATE_ADD`() או ב-`DATE_ADD`().‏ BigQuery משתמש באופרטורים אריתמטיים עבור סוגי נתונים: `INT64`,‏ `NUMERIC` ו-`FLOAT64`.`DATE_SUB`
`NLS_DATE_FORMAT`	מגדירים את פורמט התאריך של הסשן או של המערכת.	ב-BigQuery תמיד משתמשים בפורמט ISO 8601, לכן חשוב להמיר את התאריכים והשעות של Oracle.

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

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

`SELECT` דוחות

רוב ההצהרות של Oracle SELECT תואמות ל-BigQuery.

פונקציות, אופרטורים וביטויים

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

אופרטורים להשוואה

אופרטורים להשוואה ב-Oracle וב-BigQuery תואמים ל-ANSI SQL:2011. אופרטורי ההשוואה בטבלה הבאה זהים גם ב-BigQuery וגם ב-Oracle. אפשר להשתמש ב-REGEXP_CONTAINS במקום ב-REGEXP_LIKE ב-BigQuery.

אופרטור	תיאור
`"="`	שווה
`<>`	לא שווה
`!=`	לא שווה
`>`	גדול מ-
`>=`	גדול מ- או שווה ל-
`<`	פחות מ-
`<=`	קטן מ- או שווה ל-
`IN ( )`	הערך תואם לערך ברשימה
`NOT`	הופך את התנאי לשלילי
`BETWEEN`	בטווח (כולל)
`IS NULL`	`NULL` ערך
`IS NOT NULL`	לא `NULL` ערך
`LIKE`	התאמת תבניות עם %
`EXISTS`	התנאי מתקיים אם שאילתת המשנה מחזירה לפחות שורה אחת

האופרטורים בטבלה זהים גם ב-BigQuery וגם ב-Oracle.

ביטויים ופונקציות לוגיים

Oracle	BigQuery
`CASE`	`CASE`
`COALESCE`	`COALESCE(expr1, ..., exprN)`
`DECODE`	`CASE.. WHEN.. END`
`NANVL`	`IFNULL`
`FETCH NEXT>`	`LIMIT`
`NULLIF`	`NULLIF(expression, expression_to_match)`
`NVL`	`IFNULL(expr, 0), COALESCE(exp, 0)`
`NVL2`	`IF(expr, true_result, else_result)`

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

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

Oracle	BigQuery
‫`ANY_VALUE` (מ-Oracle 19c)	`ANY_VALUE`
`APPROX_COUNT`	`HLL_COUNT set of functions with specified precision`
`APPROX_COUNT_DISTINCT`	`APPROX_COUNT_DISTINCT`
`APPROX_COUNT_DISTINCT_AGG`	`APPROX_COUNT_DISTINCT`
`APPROX_COUNT_DISTINCT_DETAIL`	`APPROX_COUNT_DISTINCT`
`APPROX_PERCENTILE(percentile) WITHIN GROUP (ORDER BY expression)`	‫`APPROX_QUANTILES(expression, 100)[ OFFSET(CAST(TRUNC(percentile * 100) as INT64))]` ‫BigQuery לא תומך בשאר הארגומנטים שמוגדרים ב-Oracle.
<codeAPPROX_PERCENTILE_AGG	`APPROX_QUANTILES(expression, 100)[ OFFSET(CAST(TRUNC(percentile * 100) as INT64))]`
`APPROX_PERCENTILE_DETAIL`	`APPROX_QUANTILES(expression, 100)[OFFSET(CAST(TRUNC(percentile * 100) as INT64))]`
`APPROX_SUM`	`APPROX_TOP_SUM(expression, weight, number)`
`AVG`	`AVG`
`BIT_COMPLEMENT`	אופרטור השלילה הבינארית: ~
`BIT_OR`	`BIT_OR, X \| Y`
`BIT_XOR`	`BIT_XOR, X ^ Y`
`BITAND`	`BIT_AND, X & Y`
`CARDINALITY`	`COUNT`
`COLLECT`	‫BigQuery לא תומך ב-`TYPE AS TABLE OF`. כדאי להשתמש ב-`STRING_AGG()` או ב-`ARRAY_AGG()` ב-BigQuery
`CORR/CORR_K/` `CORR_S`	`CORR`
`COUNT`	`COUNT`
`COVAR_POP`	`COVAR_POP`
`COVAR_SAMP`	`COVAR_SAMP`
`FIRST`	לא קיים באופן מרומז ב-BigQuery. כדאי להשתמש בפונקציות בהגדרת המשתמש (UDF).
`GROUP_ID`	לא בשימוש ב-BigQuery
`GROUPING`	`GROUPING`
`GROUPING_ID`	לא בשימוש ב-BigQuery.
`LAST`	לא קיים באופן מרומז ב-BigQuery. כדאי להשתמש בפונקציות מוגדרות על ידי המשתמש (UDF).
`LISTAGG`	`STRING_AGG, ARRAY_CONCAT_AGG(expression [ORDER BY key [{ASC\|DESC}] [, ... ]] [LIMIT n])`
`MAX`	`MAX`
`MIN`	`MIN`
`OLAP_CONDITION`	ספציפי ל-Oracle, לא קיים ב-BigQuery.
`OLAP_EXPRESSION`	ספציפי ל-Oracle, לא קיים ב-BigQuery.
`OLAP_EXPRESSION_BOOL`	ספציפי ל-Oracle, לא קיים ב-BigQuery.
`OLAP_EXPRESSION_DATE`	ספציפי ל-Oracle, לא קיים ב-BigQuery.
`OLAP_EXPRESSION_TEXT`	ספציפי ל-Oracle, לא קיים ב-BigQuery.
`OLAP_TABLE`	ספציפי ל-Oracle, לא קיים ב-BigQuery.
`POWERMULTISET`	ספציפי ל-Oracle, לא קיים ב-BigQuery.
`POWERMULTISET_BY_CARDINALITY`	ספציפי ל-Oracle, לא קיים ב-BigQuery.
`QUALIFY`	ספציפי ל-Oracle, לא קיים ב-BigQuery.
`REGR_AVGX`	`AVG(` `IF(dep_var_expr is NULL` `OR ind_var_expr is NULL,` `NULL, ind_var_expr)` `)`
`REGR_AVGY`	`AVG(` `IF(dep_var_expr is NULL` `OR ind_var_expr is NULL,` `NULL, dep_var_expr)` `)`
`REGR_COUNT`	`SUM(` `IF(dep_var_expr is NULL` `OR ind_var_expr is NULL,` `NULL, 1)` `)`
`REGR_INTERCEPT`	`AVG(dep_var_expr) - AVG(ind_var_expr) * (COVAR_SAMP(ind_var_expr,dep_var_expr) / VARIANCE(ind_var_expr) )`
`REGR_R2`	`(COUNT(dep_var_expr) * SUM(ind_var_expr * dep_var_expr) - SUM(dep_var_expr) * SUM(ind_var_expr)) / SQRT( (COUNT(ind_var_expr) * SUM(POWER(ind_var_expr, 2)) * POWER(SUM(ind_var_expr),2)) * (COUNT(dep_var_expr) * SUM(POWER(dep_var_expr, 2)) * POWER(SUM(dep_var_expr), 2)))`
`REGR_SLOPE`	`COVAR_SAMP(ind_var_expr,` `dep_var_expr)` `/ VARIANCE(ind_var_expr)`
`REGR_SXX`	`SUM(POWER(ind_var_expr, 2)) - COUNT(ind_var_expr) * POWER(AVG(ind_var_expr),2)`
`REGR_SXY`	`SUM(ind_var_exprdep_var_expr) - COUNT(ind_var_expr) AVG(ind) * AVG(dep_var_expr)`
`REGR_SYY`	`SUM(POWER(dep_var_expr, 2)) - COUNT(dep_var_expr) * POWER(AVG(dep_var_expr),2)`
`ROLLUP`	`ROLLUP`
`STDDEV_POP`	`STDDEV_POP`
`STDDEV_SAMP`	`STDDEV_SAMP, STDDEV`
`SUM`	`SUM`
`VAR_POP`	`VAR_POP`
`VAR_SAMP`	`VAR_SAMP, VARIANCE`
`WM_CONCAT`	`STRING_AGG`

‫BigQuery מציע את פונקציות הצבירה הנוספות הבאות:

פונקציות אנליטיות

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

Oracle	BigQuery
`AVG`	`AVG`
`BIT_COMPLEMENT`	אופרטור השלילה הבינארית: ~
`BIT_OR`	`BIT_OR, X \| Y`
`BIT_XOR`	`BIT_XOR, X ^ Y`
`BITAND`	`BIT_AND, X & Y`
`BOOL_TO_INT`	`CAST(X AS INT64)`
`COUNT`	`COUNT`
`COVAR_POP`	`COVAR_POP`
`COVAR_SAMP`	`COVAR_SAMP`
`CUBE_TABLE`	לא נתמך ב-BigQuery. כדאי להשתמש בכלי BI או בפונקציה מוגדרת על ידי המשתמש (UDF) בהתאמה אישית
`CUME_DIST`	`CUME_DIST`
`DENSE_RANK(ANSI)`	`DENSE_RANK`
`FEATURE_COMPARE`	לא קיים באופן מרומז ב-BigQuery. כדאי להשתמש בפונקציות מוגדרות על ידי המשתמש (UDF) וב-BigQuery ML
`FEATURE_DETAILS`	לא קיים באופן מרומז ב-BigQuery. כדאי להשתמש בפונקציות מוגדרות על ידי המשתמש (UDF) וב-BigQuery ML
`FEATURE_ID`	לא קיים באופן מרומז ב-BigQuery. כדאי להשתמש בפונקציות מוגדרות על ידי המשתמש (UDF) וב-BigQuery ML
`FEATURE_SET`	לא קיים באופן מרומז ב-BigQuery. כדאי להשתמש בפונקציות מוגדרות על ידי המשתמש (UDF) וב-BigQuery ML
`FEATURE_VALUE`	לא קיים באופן מרומז ב-BigQuery. כדאי להשתמש בפונקציות מוגדרות על ידי המשתמש (UDF) וב-BigQuery ML
`FIRST_VALUE`	`FIRST_VALUE`
`HIER_CAPTION`	אין תמיכה בשאילתות היררכיות ב-BigQuery.
`HIER_CHILD_COUNT`	אין תמיכה בשאילתות היררכיות ב-BigQuery.
`HIER_COLUMN`	אין תמיכה בשאילתות היררכיות ב-BigQuery.
`HIER_DEPTH`	אין תמיכה בשאילתות היררכיות ב-BigQuery.
`HIER_DESCRIPTION`	אין תמיכה בשאילתות היררכיות ב-BigQuery.
`HIER_HAS_CHILDREN`	אין תמיכה בשאילתות היררכיות ב-BigQuery.
`HIER_LEVEL`	אין תמיכה בשאילתות היררכיות ב-BigQuery.
`HIER_MEMBER_NAME`	אין תמיכה בשאילתות היררכיות ב-BigQuery.
`HIER_ORDER`	אין תמיכה בשאילתות היררכיות ב-BigQuery.
`HIER_UNIQUE_MEMBER_NAME`	אין תמיכה בשאילתות היררכיות ב-BigQuery.
`LAST_VALUE`	`LAST_VALUE`
`LAG`	`LAG`
`LEAD`	`LEAD`
`LISTAGG`	`ARRAY_AGG STRING_AGG ARRAY_CONCAT_AGG`
`MATCH_NUMBER`	אפשר לבצע זיהוי וחישוב של דפוסים באמצעות ביטויים רגולריים ופונקציות מוגדרות על ידי המשתמש ב-BigQuery
`MATCH_RECOGNIZE`	אפשר לבצע זיהוי וחישוב של דפוסים באמצעות ביטויים רגולריים ופונקציות מוגדרות על ידי המשתמש ב-BigQuery
`MAX`	`MAX`
`MEDIAN`	`PERCENTILE_CONT(x, 0.5 RESPECT NULLS) OVER()`
`MIN`	`MIN`
`NTH_VALUE`	`NTH_VALUE (value_expression, constant_integer_expression [{RESPECT \| IGNORE} NULLS])`
`NTILE`	`NTILE(constant_integer_expression)`
`PERCENT_RANK PERCENT_RANKM`	`PERCENT_RANK`
`PERCENTILE_CONT PERCENTILE_DISC`	`PERCENTILE_CONT`
`PERCENTILE_CONT PERCENTILE_DISC`	`PERCENTILE_DISC`
`PRESENTNNV`	ספציפי ל-Oracle, לא קיים ב-BigQuery.
`PRESENTV`	ספציפי ל-Oracle, לא קיים ב-BigQuery.
`PREVIOUS`	ספציפי ל-Oracle, לא קיים ב-BigQuery.
`RANK`(ANSI)	`RANK`
`RATIO_TO_REPORT(expr) OVER (partition clause)`	`expr / SUM(expr) OVER (partition clause)`
`ROW_NUMBER`	`ROW_NUMBER`
`STDDEV_POP`	`STDDEV_POP`
`STDDEV_SAMP`	`STDDEV_SAMP, STDDEV`
`SUM`	`SUM`
`VAR_POP`	`VAR_POP`
`VAR_SAMP`	`VAR_SAMP, VARIANCE`
`VARIANCE`	`VARIANCE()`
`WIDTH_BUCKET`	אפשר להשתמש בפונקציה UDF.

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

בטבלה הבאה מוצגים מיפויים בין פונקציות נפוצות של תאריך/שעה ב-Oracle לבין הפונקציות המקבילות ב-BigQuery.

Oracle	BigQuery
`ADD_MONTHS(date, integer)`	`DATE_ADD(date, INTERVAL integer MONTH),` אם התאריך הוא `TIMESTAMP`, אפשר להשתמש ב `EXTRACT(DATE FROM TIMESTAMP_ADD(date, INTERVAL integer MONTH))`
`CURRENT_DATE`	`CURRENT_DATE`
`CURRENT_TIME`	`CURRENT_TIME`
`CURRENT_TIMESTAMP`	`CURRENT_TIMESTAMP`
`DATE - k`	`DATE_SUB(date_expression, INTERVAL k DAY)`
`DATE + k`	`DATE_ADD(date_expression, INTERVAL k DAY)`
`DBTIMEZONE`	‫BigQuery לא תומך באזור הזמן של מסד הנתונים.
`EXTRACT`	`EXTRACT(DATE), EXTRACT(TIMESTAMP)`
`LAST_DAY`	`DATE_SUB( DATE_TRUNC( DATE_ADD( date_expression, INTERVAL 1 MONTH ), MONTH ), INTERVAL 1 DAY )`
`LOCALTIMESTAMP`	אין תמיכה בהגדרות אזור הזמן ב-BigQuery.
`MONTHS_BETWEEN`	`DATE_DIFF(date_expression, date_expression, MONTH)`
`NEW_TIME`	`DATE(timestamp_expression, time zone) TIME(timestamp, time zone) DATETIME(timestamp_expression, time zone)`
`NEXT_DAY`	`DATE_ADD( DATE_TRUNC( date_expression, WEEK(day_value) ), INTERVAL 1 WEEK )`
`SYS_AT_TIME_ZONE`	`CURRENT_DATE([time_zone])`
`SYSDATE`	`CURRENT_DATE()`
`SYSTIMESTAMP`	`CURRENT_TIMESTAMP()`
`TO_DATE`	`PARSE_DATE`
`TO_TIMESTAMP`	`PARSE_TIMESTAMP`
`TO_TIMESTAMP_TZ`	`PARSE_TIMESTAMP`
`TZ_OFFSET`	לא נתמך ב-BigQuery. אפשר להשתמש בפונקציה מותאמת אישית (UDF).
`WM_CONTAINS` `WM_EQUALS` `WM_GREATERTHAN` `WM_INTERSECTION` `WM_LDIFF` `WM_LESSTHAN` `WM_MEETS` `WM_OVERLAPS` `WM_RDIFF`	לא נעשה שימוש בתקופות ב-BigQuery. אפשר להשתמש בפונקציות UDF כדי להשוות בין שתי תקופות.

‫BigQuery מציע את הפונקציות הנוספות הבאות של תאריך ושעה:

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

בטבלה הבאה מוצגים מיפויים בין פונקציות מחרוזות של Oracle לבין הפונקציות המקבילות שלהן ב-BigQuery:

Oracle	BigQuery
`ASCII`	`TO_CODE_POINTS(string_expr)[OFFSET(0)]`
`ASCIISTR`	אין תמיכה ב-UTF-16 ב-BigQuery
`RAWTOHEX`	`TO_HEX`
`LENGTH`	`CHAR_LENGTH`
`LENGTH`	`CHARACTER_LENGTH`
`CHR`	`CODE_POINTS_TO_STRING( [mod(numeric_expr, 256)] )`
`COLLATION`	לא קיים ב-BigQuery. ‫BigQuery לא תומך ב-COLLATE ב-DML
`COMPOSE`	פונקציה בהגדרת המשתמש (UDF) מותאמת אישית.
`CONCAT, (\|\| operator)`	`CONCAT`
`DECOMPOSE`	פונקציה בהגדרת המשתמש (UDF) מותאמת אישית.
`ESCAPE_REFERENCE (UTL_I18N)`	אין תמיכה ב-BigQuery. מומלץ להשתמש בפונקציה בהגדרת המשתמש.
`INITCAP`	`INITCAP`
`INSTR/INSTR2/INSTR4/INSTRB/INSTRC`	פונקציה בהגדרת המשתמש (UDF) מותאמת אישית.
`LENGTH/LENGTH2/LENGTH4/LENGTHB/LENGTHC`	`LENGTH`
`LOWER`	`LOWER`
`LPAD`	`LPAD`
`LTRIM`	`LTRIM`
`NLS_INITCAP`	פונקציה בהגדרת המשתמש (UDF) מותאמת אישית.
`NLS_LOWER`	`LOWER`
`NLS_UPPER`	`UPPER`
`NLSSORT`	ספציפי ל-Oracle, לא קיים ב-BigQuery.
`POSITION`	`STRPOS(string, substring)`
`PRINTBLOBTOCLOB`	ספציפי ל-Oracle, לא קיים ב-BigQuery.
`REGEXP_COUNT`	`ARRAY_LENGTH(REGEXP_EXTRACT_ALL(value, regex))`
`REGEXP_INSTR`	`STRPOS(source_string, REGEXP_EXTRACT(source_string, regexp_string))` הערה: הפונקציה מחזירה את המופע הראשון.
`REGEXP_REPLACE`	`REGEXP_REPLACE`
`REGEXP_LIKE`	`IF(REGEXP_CONTAINS,1,0)`
`REGEXP_SUBSTR`	`REGEXP_EXTRACT, REGEXP_EXTRACT_ALL`
`REPLACE`	`REPLACE`
`REVERSE`	`REVERSE`
`RIGHT`	`SUBSTR(source_string, -1, length)`
`RPAD`	`RPAD`
`RTRIM`	`RTRIM`
`SOUNDEX`	לא נתמך ב-BigQuery. כדאי להשתמש בפונקציה מוגדרת על ידי המשתמש (UDF) בהתאמה אישית
`STRTOK`	`SPLIT(instring, delimiter)[ORDINAL(tokennum)]` `Note: The entire delimiter string argument is used as a single delimiter. The default delimiter is a comma.`
`SUBSTR/SUBSTRB/SUBSTRC/SUBSTR2/SUBSTR4`	`SUBSTR`
`TRANSLATE`	`REPLACE`
`TRANSLATE USING`	`REPLACE`
`TRIM`	`TRIM`
`UNISTR`	`CODE_POINTS_TO_STRING`
`UPPER`	`UPPER`
`\|\|` (עמודות אנכיות)	`CONCAT`

‫BigQuery מציע את הפונקציות הנוספות הבאות למחרוזות:

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

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

Oracle	BigQuery
`ABS`	`ABS`
`ACOS`	`ACOS`
`ACOSH`	`ACOSH`
`ASIN`	`ASIN`
`ASINH`	`ASINH`
`ATAN`	`ATAN`
`ATAN2`	`ATAN2`
`ATANH`	`ATANH`
`CEIL`	`CEIL`
`CEILING`	`CEILING`
`COS`	`COS`
`COSH`	`COSH`
`EXP`	`EXP`
`FLOOR`	`FLOOR`
`GREATEST`	`GREATEST`
`LEAST`	`LEAST`
`LN`	`LN`
`LNNVL`	שימוש עם `ISNULL`
`LOG`	`LOG`
`MOD (% operator)`	`MOD`
`POWER (** operator)`	`POWER, POW`
`DBMS_RANDOM.VALUE`	`RAND`
`RANDOMBYTES`	לא נתמך ב-BigQuery. כדאי להשתמש בפונקציה מוגדרת על ידי המשתמש (UDF) בהתאמה אישית ובפונקציה RAND
`RANDOMINTEGER`	`CAST(FLOOR(10*RAND()) AS INT64)`
`RANDOMNUMBER`	לא נתמך ב-BigQuery. כדאי להשתמש בפונקציה מוגדרת על ידי המשתמש (UDF) בהתאמה אישית ובפונקציה RAND
`REMAINDER`	`MOD`
`ROUND`	`ROUND`
`ROUND_TIES_TO_EVEN`	`ROUND()`
`SIGN`	`SIGN`
`SIN`	`SIN`
`SINH`	`SINH`
`SQRT`	`SQRT`
`STANDARD_HASH`	`FARM_FINGERPRINT, MD5, SHA1, SHA256, SHA512`
`STDDEV`	STDDEV
`TAN`	`TAN`
`TANH`	`TANH`
`TRUNC`	`TRUNC`
`NVL`	`IFNULL(expr, 0), COALESCE(exp, 0)`

ב-BigQuery יש פונקציות מתמטיות נוספות:

פונקציות להמרת סוגים

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

Oracle	BigQuery
`BIN_TO_NUM`	`SAFE_CONVERT_BYTES_TO_STRING(value)` `CAST(x AS INT64)`
`BINARY2VARCHAR`	`SAFE_CONVERT_BYTES_TO_STRING(value)`
`CAST CAST_FROM_BINARY_DOUBLE CAST_FROM_BINARY_FLOAT CAST_FROM_BINARY_INTEGER CAST_FROM_NUMBER CAST_TO_BINARY_DOUBLE CAST_TO_BINARY_FLOAT CAST_TO_BINARY_INTEGER CAST_TO_NUMBER CAST_TO_NVARCHAR2 CAST_TO_RAW >CAST_TO_VARCHAR`	`CAST(expr AS typename)`
`CHARTOROWID`	לא נדרש ידע ספציפי ב-Oracle.
`CONVERT`	אין תמיכה בערכות תווים ב-BigQuery. מומלץ להשתמש בפונקציה בהגדרת המשתמש (UDF).
`EMPTY_BLOB`	לא נעשה שימוש ב-`BLOB` ב-BigQuery.
`EMPTY_CLOB`	לא נעשה שימוש ב-`CLOB` ב-BigQuery.
`FROM_TZ`	אין תמיכה בסוגים עם אזורי זמן ב-BigQuery. מומלץ להשתמש בפונקציה בהגדרת המשתמש וב-FORMAT_TIMESTAMP
`INT_TO_BOOL`	`CAST`
`IS_BIT_SET`	לא קיים באופן מרומז ב-BigQuery. כדאי להשתמש בפונקציות UDF
`NCHR`	אפשר להשתמש ב-UDF כדי לקבל את התו המקביל לערך בינארי
`NUMTODSINTERVAL`	סוג הנתונים `INTERVAL` לא נתמך ב-BigQuery
`NUMTOHEX`	לא נתמך ב-BigQuery. כדאי להשתמש בפונקציה בהתאמה אישית (UDF) ובפונקציה `TO_HEX`
`NUMTOHEX2`
`NUMTOYMINTERVAL`	סוג הנתונים `INTERVAL` לא נתמך ב-BigQuery.
`RAW_TO_CHAR`	ספציפי ל-Oracle, לא קיים ב-BigQuery.
`RAW_TO_NCHAR`	ספציפי ל-Oracle, לא קיים ב-BigQuery.
`RAW_TO_VARCHAR2`	ספציפי ל-Oracle, לא קיים ב-BigQuery.
`RAWTOHEX`	ספציפי ל-Oracle, לא קיים ב-BigQuery.
`RAWTONHEX`	ספציפי ל-Oracle, לא קיים ב-BigQuery.
`RAWTONUM`	ספציפי ל-Oracle, לא קיים ב-BigQuery.
`RAWTONUM2`	ספציפי ל-Oracle, לא קיים ב-BigQuery.
`RAWTOREF`	ספציפי ל-Oracle, לא קיים ב-BigQuery.
`REFTOHEX`	ספציפי ל-Oracle, לא קיים ב-BigQuery.
`REFTORAW`	ספציפי ל-Oracle, לא קיים ב-BigQuery.
`ROWIDTOCHAR`	‫`ROWID` הוא סוג ספציפי ל-Oracle ולא קיים ב-BigQuery. הערך הזה צריך להיות מיוצג כמחרוזת.
`ROWIDTONCHAR`	‫`ROWID` הוא סוג ספציפי ל-Oracle ולא קיים ב-BigQuery. הערך הזה צריך להיות מיוצג כמחרוזת.
`SCN_TO_TIMESTAMP`	‫`SCN` הוא סוג ספציפי ל-Oracle ולא קיים ב-BigQuery. הערך הזה צריך להיות מיוצג כחותמת זמן.
`TO_ACLID TO_ANYLOB TO_APPROX_COUNT_DISTINCT TO_APPROX_PERCENTILE TO_BINARY_DOUBLE TO_BINARY_FLOAT TO_BLOB TO_CHAR TO_CLOB TO_DATE TO_DSINTERVAL TO_LOB TO_MULTI_BYTE TO_NCHAR TO_NCLOB TO_NUMBER TO_RAW TO_SINGLE_BYTE TO_TIME` TO_TIMESTAMP TO_TIMESTAMP_TZ TO_TIME_TZ TO_UTC_TIMEZONE_TZ TO_YMINTERVAL	`CAST(expr AS typename)` `PARSE_DATE` `PARSE_TIMESTAMP` משתמשים בתחביר של המרה (cast) בשאילתה כדי לציין שסוג התוצאה של ביטוי צריך להיות מומר לסוג אחר.
`TREAT`	ספציפי ל-Oracle, לא קיים ב-BigQuery.
`VALIDATE_CONVERSION`	לא נתמך ב-BigQuery. כדאי להשתמש בפונקציה מוגדרת על ידי המשתמש (UDF) בהתאמה אישית
`VSIZE`	לא נתמך ב-BigQuery. כדאי להשתמש בפונקציה מוגדרת על ידי המשתמש (UDF) בהתאמה אישית

פונקציות JSON

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

Oracle	BigQuery
`AS_JSON`	`TO_JSON_STRING(value[, pretty_print])`
`JSON_ARRAY`	כדאי להשתמש בפונקציות מוגדרות על ידי המשתמש ובפונקציה `TO_JSON_STRING`
`JSON_ARRAYAGG`	כדאי להשתמש בפונקציות מוגדרות על ידי המשתמש ובפונקציה `TO_JSON_STRING`
`JSON_DATAGUIDE`	פונקציה בהגדרת המשתמש (UDF) מותאמת אישית.
`JSON_EQUAL`	פונקציה בהגדרת המשתמש (UDF) מותאמת אישית.
`JSON_EXIST`	כדאי להשתמש בפונקציות מוגדרות על ידי המשתמש (UDF) וב-`JSON_EXTRACT` או ב-`JSON_EXTRACT_SCALAR`
`JSON_MERGEPATCH`	פונקציה בהגדרת המשתמש (UDF) מותאמת אישית.
`JSON_OBJECT`	לא נתמך על ידי BigQuery.
`JSON_OBJECTAGG`	לא נתמך על ידי BigQuery.
`JSON_QUERY`	כדאי להשתמש בפונקציות מוגדרות על ידי המשתמש (UDF) וב-`JSON_EXTRACT` או ב-`JSON_EXTRACT_SCALAR`.
`JSON_TABLE`	פונקציה בהגדרת המשתמש (UDF) מותאמת אישית.
`JSON_TEXTCONTAINS`	כדאי להשתמש בפונקציות מוגדרות על ידי המשתמש (UDF) וב-`JSON_EXTRACT` או ב-`JSON_EXTRACT_SCALAR`.
`JSON_VALUE`	`JSON_EXTRACT_SCALAR`

פונקציות XML

‫BigQuery לא מספק פונקציות XML מרומזות. אפשר לטעון XML ל-BigQuery כמחרוזת, ולהשתמש בפונקציות מוגדרות על ידי המשתמש (UDF) כדי לנתח XML. לחלופין, אפשר לעבד את ה-XML באמצעות כלי ETL/ELT כמו Dataflow. ברשימה הבאה מוצגות פונקציות של Oracle XML:

Oracle	BigQuery
`DELETEXML`	אפשר להשתמש ב-UDF של BigQuery או בכלי ETL כמו Dataflow כדי לעבד XML.
`ENCODE_SQL_XML`
`EXISTSNODE`
`EXTRACTCLOBXML`
`EXTRACTVALUE`
`INSERTCHILDXML`
`INSERTCHILDXMLAFTER`
`INSERTCHILDXMLBEFORE`
`INSERTXMLAFTER`
`INSERTXMLBEFORE`
`SYS_XMLAGG`
`SYS_XMLANALYZE`
`SYS_XMLCONTAINS`
`SYS_XMLCONV`
`SYS_XMLEXNSURI`
`SYS_XMLGEN`
`SYS_XMLI_LOC_ISNODE`
`SYS_XMLI_LOC_ISTEXT`
`SYS_XMLINSTR`
`SYS_XMLLOCATOR_GETSVAL`
`SYS_XMLNODEID`
`SYS_XMLNODEID_GETLOCATOR`
`SYS_XMLNODEID_GETOKEY`
`SYS_XMLNODEID_GETPATHID`
`SYS_XMLNODEID_GETPTRID`
`SYS_XMLNODEID_GETRID`
`SYS_XMLNODEID_GETSVAL`
`SYS_XMLT_2_SC`
`SYS_XMLTRANSLATE`
`SYS_XMLTYPE2SQL`
`UPDATEXML`
`XML2OBJECT`
`XMLCAST`
`XMLCDATA`
`XMLCOLLATVAL`
`XMLCOMMENT`
`XMLCONCAT`
`XMLDIFF`
`XMLELEMENT`
`XMLEXISTS`
`XMLEXISTS2`
`XMLFOREST`
`XMLISNODE`
`XMLISVALID`
`XMLPARSE`
`XMLPATCH`
`XMLPI`
`XMLQUERY`
`XMLQUERYVAL`
`XMLSERIALIZE`
`XMLTABLE`
`XMLTOJSON`
`XMLTRANSFORM`
`XMLTRANSFORMBLOB`
`XMLTYPE`

פונקציות של למידת מכונה

פונקציות של למידת מכונה (ML) ב-Oracle וב-BigQuery שונות זו מזו. ב-Oracle נדרשים חבילת ניתוח מתקדם ורישיונות כדי להפעיל למידת מכונה במסד הנתונים. ‫Oracle משתמשת בחבילה DBMS_DATA_MINING ללמידת מכונה. כדי להמיר משימות של Oracle Data Miner, צריך לכתוב מחדש את הקוד כדי לעבוד עם התכונות של BigQuery. אתם יכולים לבחור מתוך מגוון מוצרי AI של Google, כולל המוצרים והתכונות הבאים:

אתם יכולים להשתמש ב-BigQuery ML או בכלים לפיתוח ב-Vertex AI כדי לפתח, לאמן ולהעריך מודלים של למידת מכונה.

בטבלה הבאה מוצגות פונקציות של Oracle ML:

Oracle	BigQuery
`CLASSIFIER`	כאן אפשר לקרוא על אפשרויות של סיווג ורגרסיה של למידת מכונה ב-BigQuery ML
`CLUSTER_DETAILS`
`CLUSTER_DISTANCE`
`CLUSTER_ID`
`CLUSTER_PROBABILITY`
`CLUSTER_SET`
`PREDICTION`
`PREDICTION_BOUNDS`
`PREDICTION_COST`
`PREDICTION_DETAILS`
`PREDICTION_PROBABILITY`
`PREDICTION_SET`

פונקציות אבטחה

בטבלה הבאה מפורטות הפונקציות לזיהוי המשתמש ב-Oracle וב-BigQuery:

Oracle	BigQuery
`UID`	`SESSION_USER`
`USER/SESSION_USER/CURRENT_USER`	`SESSION_USER()`

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

בטבלה הבאה מוצגות פונקציות של קבוצות או מערכים ב-Oracle והפונקציות המקבילות שלהן ב-BigQuery:

Oracle	BigQuery
`MULTISET`	`ARRAY_AGG`
`MULTISET EXCEPT`	`ARRAY_AGG([DISTINCT] expression)`
`MULTISET INTERSECT`	`ARRAY_AGG([DISTINCT])`
`MULTISET UNION`	`ARRAY_AGG`

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

בטבלה הבאה מוצגות פונקציות חלון ב-Oracle והפונקציות המקבילות שלהן ב-BigQuery.

Oracle	BigQuery
`LAG`	`LAG (value_expression[, offset [, default_expression]])`
`LEAD`	`LEAD (value_expression[, offset [, default_expression]])`

שאילתות היררכיות או רקורסיביות

שאילתות היררכיות או רקורסיביות לא נמצאות בשימוש ב-BigQuery. אם ידוע העומק של ההיררכיה, אפשר להשיג פונקציונליות דומה באמצעות הצטרפות, כפי שמוצג בדוגמה הבאה. פתרון נוסף הוא להשתמש ב-BigQueryStorage API וב-Spark.

select
  array(
    select e.update.element
    union all
    select c1 from e.update.element.child as c1
    union all
    select c2 from e.update.element.child as c1, c1.child as c2
    union all
    select c3 from e.update.element.child as c1, c1.child as c2, c2.child as c3
    union all
    select c4 from e.update.element.child as c1, c1.child as c2, c2.child as c3, c3.child as c4
    union all
    select c5 from e.update.element.child as c1, c1.child as c2, c2.child as c3, c3.child as c4, c4.child as c5
  ) as flattened,
  e as event
from t, t.events as e

בטבלה הבאה מוצגות פונקציות היררכיות ב-Oracle.

Oracle	BigQuery
`DEPTH`	ב-BigQuery לא נעשה שימוש בשאילתות היררכיות.
`PATH`
`SYS_CONNECT_BY_PATH (hierarchical)`

פונקציות UTL

‫UTL_File חבילה משמשת בעיקר לקריאה ולכתיבה של קבצי מערכת ההפעלה מ-PL/SQL. אפשר להשתמש ב-Cloud Storage לכל סוג של העברה זמנית של קובץ גולמי. כדי לקרוא ולכתוב קבצים מ-Cloud Storage ואליו, צריך להשתמש בטבלאות חיצוניות ובטעינה וייצוא של BigQuery. מידע נוסף זמין במאמר מבוא למקורות נתונים חיצוניים.

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

אתם יכולים להשתמש בניתוח נתונים גיאו-מרחביים ב-BigQuery כדי להחליף את הפונקציונליות של spatial. יש SDO_* פונקציות וסוגים ב-Oracle, כמו SDO_GEOM_KEY, ‏ SDO_GEOM_MBR ו-SDO_GEOM_MMB. הפונקציות האלה משמשות לניתוח מרחבי. אתם יכולים להשתמש בניתוח נתונים גיאו-מרחביים כדי לבצע ניתוח מרחבי.

תחביר DML

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

`INSERT` דוחות

רוב ההצהרות של Oracle INSERT תואמות ל-BigQuery. בטבלה הבאה מוצגים חריגים.

לסקריפטים של DML ב-BigQuery יש סמנטיקה של עקביות שונה מעט מההצהרות המקבילות ב-Oracle. סקירה כללית על בידוד תמונת מצב ועל טיפול בסשנים ובעסקאות מופיעה במקום אחר במסמך הזה, בקטע CREATE [UNIQUE] INDEX section.

Oracle BigQuery

Oracle	BigQuery
`INSERT INTO table VALUES (...);`	`INSERT INTO table (...) VALUES (...);` ‫Oracle מציעה מילת מפתח `DEFAULT` לעמודות שלא יכולות להכיל ערך null. הערה: ב-BigQuery, השמטת שמות העמודות בהצהרת `INSERT` פועלת רק אם הערכים של כל העמודות בטבלת היעד כלולים בסדר עולה על סמך המיקומים הסידוריים שלהם.
`INSERT INTO table VALUES (1,2,3); INSERT INTO table VALUES (4,5,6); INSERT INTO table VALUES (7,8,9); INSERT ALL INTO table (col1, col2) VALUES ('val1_1', 'val1_2') INTO table (col1, col2) VALUES ('val2_1', 'val2_2') INTO table (col1, col2) VALUES ('val3_1', 'val3_2') . . . SELECT 1 FROM DUAL;`	`INSERT INTO table VALUES (1,2,3), (4,5,6), (7,8,9);` ב-BigQuery יש מכסות DML שמגבילות את מספר הצהרות ה-DML שאפשר להריץ מדי יום. כדי להפיק את המרב מהמכסה, כדאי להשתמש בשיטות הבאות: לשלב כמה שורות בהצהרת `INSERT` אחת, במקום שורה אחת לכל פעולת `INSERT`. לשלב כמה פקודות DML (כולל `INSERT`) באמצעות פקודת `MERGE`. משתמשים ב-`CREATE TABLE ... AS SELECT` כדי ליצור טבלאות חדשות ולאכלס אותן.

INSERT INTO table VALUES (...);

INSERT INTO table (...) VALUES (...);

‫Oracle מציעה מילת מפתח DEFAULT לעמודות שלא יכולות להכיל ערך null.

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

INSERT INTO table VALUES (1,2,3);

    INSERT INTO table VALUES (4,5,6);

    INSERT INTO table VALUES (7,8,9);

    INSERT ALL

    INTO table (col1, col2) VALUES ('val1_1', 'val1_2')

    INTO table (col1, col2) VALUES ('val2_1', 'val2_2')

    INTO table (col1, col2) VALUES ('val3_1', 'val3_2')

    .

    .

    .

    SELECT 1 FROM DUAL;

INSERT INTO table VALUES (1,2,3),
(4,5,6),
(7,8,9);

ב-BigQuery יש מכסות DML שמגבילות את מספר הצהרות ה-DML שאפשר להריץ מדי יום. כדי להפיק את המרב מהמכסה, כדאי להשתמש בשיטות הבאות:

לשלב כמה שורות בהצהרת INSERT אחת, במקום שורה אחת לכל פעולת INSERT.
לשלב כמה פקודות DML (כולל INSERT) באמצעות פקודת MERGE.
משתמשים ב-CREATE TABLE ... AS SELECT כדי ליצור טבלאות חדשות ולאכלס אותן.

`UPDATE` דוחות

הצהרות Oracle UPDATE תואמות ברובן ל-BigQuery, אבל ב-BigQuery להצהרת UPDATE חייב להיות סעיף WHERE.

מומלץ להשתמש בהצהרות DML של קבוצות במקום בהצהרות UPDATE וINSERT יחידות מרובות. לסקריפטים של DML ב-BigQuery יש סמנטיקה של עקביות ששונה מעט מהצהרות מקבילות ב-Oracle. סקירה כללית על בידוד snapshot, ועל ניהול של סשנים ועסקאות מופיעה בקטע CREATE INDEX במסמך הזה.

בטבלה הבאה מוצגות הצהרות של Oracle UPDATE והצהרות של BigQuery שמבצעות את אותן המשימות.

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

`DELETE` ודוחות `TRUNCATE`

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

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

Oracle	BigQuery
`DELETE database.table;`	`DELETE FROM table WHERE TRUE;`

`MERGE` דוחות

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

עם זאת, לסקריפטים של DML ב-BigQuery יש סמנטיקה של עקביות שונה מעט מההצהרות המקבילות ב-Oracle.

תחביר DDL

בקטע הזה מוסבר על ההבדלים בתחביר של שפת הגדרת הנתונים (DDL) בין Oracle לבין BigQuery.

`CREATE TABLE` דוחות

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

STORAGE
TABLESPACE
DEFAULT
GENERATED ALWAYS AS
ENCRYPT
‫PRIMARY KEY (col, ...). מידע נוסף זמין במאמר CREATE INDEX.
‫UNIQUE INDEX. מידע נוסף זמין במאמר CREATE INDEX.
CONSTRAINT..REFERENCES
DEFAULT
PARALLEL
COMPRESS

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

אפשרויות לעמודות ומאפיינים

עמודות זהות הוצגו בגרסה Oracle 12c, שמאפשרת הגדלה אוטומטית של ערך בעמודה. השיטה הזו לא מתאימה ל-BigQuery, אבל אפשר להשתמש בשיטה הבאה כדי לבצע את הפעולה הזו. למידע נוסף על מפתחות סרוגייט (surrogate) ועל מאפיינים שמשתנים לאט (SCD), אפשר לעיין במדריכים הבאים:

Oracle	BigQuery
`CREATE TABLE table ( id NUMBER GENERATED ALWAYS AS IDENTITY, description VARCHAR2(30) );`	`INSERT INTO dataset.table SELECT *, ROW_NUMBER() OVER () AS id FROM dataset.table`

תגובות בעמודה

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

Oracle	BigQuery
`Comment on column table is 'column desc';`	`CREATE TABLE dataset.table ( col1 STRING OPTIONS(description="column desc") );`

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

‫Oracle תומכת בטבלאות זמניות, שמשמשות לעיתים קרובות לאחסון תוצאות ביניים בסקריפטים. ‫Temporary (זמניות) נתמכות ב-BigQuery.

Oracle	BigQuery
`CREATE GLOBAL TEMPORARY TABLE temp_tab (x INTEGER, y VARCHAR2(50)) ON COMMIT DELETE ROWS; COMMIT;`	`CREATE TEMP TABLE temp_tab ( x INT64, y STRING ); DELETE FROM temp_tab WHERE TRUE;`

האלמנטים הבאים של Oracle לא נמצאים בשימוש ב-BigQuery:

ON COMMIT DELETE ROWS;
ON COMMIT PRESERVE ROWS;

יש גם כמה דרכים אחרות לדמות טבלאות זמניות ב-BigQuery:

אורך החיים של מערך הנתונים: יוצרים מערך נתונים עם אורך חיים קצר (לדוגמה, שעה אחת), כך שכל הטבלאות שנוצרות במערך הנתונים הן למעשה זמניות (כי הן לא יישמרו מעבר לאורך החיים של מערך הנתונים). אפשר להוסיף את התחילית temp לכל שמות הטבלאות במערך הנתונים הזה כדי לציין בבירור שהטבלאות הן זמניות.
Table TTL: יוצרים טבלה עם זמן קצר לחיים (TTL) שספציפי לטבלה באמצעות הצהרות DDL שדומות לאלה:
```
CREATE TABLE temp.name (col1, col2, ...)

OPTIONS(expiration_timestamp=TIMESTAMP_ADD(CURRENT_TIMESTAMP(), INTERVAL 1 HOUR));
```
‫WITH clause: אם נדרש טבלה זמנית רק בתוך אותו בלוק, משתמשים בתוצאה זמנית באמצעות משפט WITH או שאילתת משנה.

`CREATE SEQUENCE` דוחות

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

INSERT INTO dataset.table
    SELECT *,
      ROW_NUMBER() OVER () AS id
      FROM dataset.table

`CREATE VIEW` דוחות

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

Oracle	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 IF NOT EXISTS` `view_name` `OPTIONS(view_option_list)` `AS SELECT ...`	יוצרת תצוגה חדשה רק אם התצוגה לא קיימת כרגע במערך הנתונים שצוין.

`CREATE MATERIALIZED VIEW` דוחות

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

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

לעומת זאת, אם בוצעו עדכונים (DML UPDATE / MERGE) או מחיקות (DML DELETE, truncation, partition expiration) בטבלת הבסיס מאז הרענון האחרון של התצוגה, התצוגה החומרית לא תיסרק ולכן לא יתקבלו חיסכון בשאילתות עד לרענון הבא של התצוגה. בעצם, כל עדכון או מחיקה בטבלת הבסיס מבטלים את מצב התצוגה החומרית.

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

בטבלה הבאה מוצגים מקבילים בין Oracle לבין BigQuery עבור הצהרת CREATE MATERIALIZED VIEW.

Oracle	BigQuery	הערות
`CREATE MATERIALIZED VIEW view_name REFRESH FAST NEXT sysdate + 7 AS SELECT … FROM TABLE_1`	`CREATE MATERIALIZED VIEW view_name AS SELECT ...`

`CREATE [UNIQUE] INDEX` דוחות

בקטע הזה מתוארות גישות ב-BigQuery ליצירת פונקציונליות דומה לזו של אינדקסים ב-Oracle.

יצירת אינדקס לשיפור הביצועים

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

יצירת אינדקסים לשמירה על עקביות (UNIQUE, ‏ PRIMARY INDEX)

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

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

כדי ליצור שגיאה עבור רשומות כפולות ב-BigQuery, אפשר להשתמש בהצהרת MERGE מטבלת הביניים, כמו בדוגמה הבאה:

Oracle		BigQuery
`CREATE [UNIQUE] INDEX name;`		MERGE `prototype.FIN_MERGE` t \ USING `prototype.FIN_TEMP_IMPORT` m \ ON t.col1 = m.col1 \ AND t.col2 = m.col2 \ WHEN MATCHED THEN \ UPDATE SET t.col1 = ERROR(CONCAT('Encountered Error for ', m.col1, ' ', m.col2)) \ WHEN NOT MATCHED THEN \ INSERT (col1,col2,col3,col4,col5,col6,col7,col8) VALUES(col1,col2,col3,col4,col5,col6, CURRENT_TIMESTAMP(),CURRENT_TIMESTAMP());

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

‫BigQuery לא תומך בעמודות DEFAULT ו-IDENTITY (רצפים).

נעילה

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

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

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

`CREATE PROCEDURE` דוחות

התכונה 'תהליך מאוחסן' נתמכת כחלק מגרסת הבטא של BigQuery Scripting.

Oracle	BigQuery	הערות
`CREATE PROCEDURE`	`CREATE PROCEDURE`	בדומה ל-Oracle, ‏ BigQuery תומך ב`IN, OUT, INOUT` מצבי ארגומנט. אין תמיכה במפרטי תחביר אחרים ב-BigQuery.
`CREATE OR REPLACE PROCEDURE`	`CREATE OR REPLACE PROCEDURE`
`CALL`	`CALL`

בקטעים הבאים מתוארות דרכים להמיר הצהרות פרוצדורליות קיימות של Oracle להצהרות סקריפטים של BigQuery עם פונקציונליות דומה.

`CREATE TRIGGER` דוחות

לא נעשה שימוש בטריגרים ב-BigQuery. לוגיקת אפליקציה מבוססת-שורה צריכה להיות מטופלת בשכבת האפליקציה. אפשר להפעיל את הפונקציונליות של הטריגר באמצעות כלי ההטמעה, Pub/Sub ו/או פונקציות Cloud Run במהלך ההטמעה או באמצעות סריקות רגילות.

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

בטבלה הבאה מוצגים משפטי Oracle DECLAREוהמשפטים המקבילים ב-BigQuery.

Oracle	BigQuery
`DECLARE L_VAR NUMBER; BEGIN L_VAR := 10 + 20; END;`	`DECLARE L_VAR int64; BEGIN SET L_VAR = 10 + 20; SELECT L_VAR; END`
`SET var = value;`	`SET var = value;`

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

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

DECLARE cursor_name CURSOR [FOR | WITH] ...
OPEN CUR_VAR FOR sql_str;
OPEN cursor_name [USING var, ...];
FETCH cursor_name INTO var, ...;
CLOSE cursor_name;

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

ההצהרה הבאה של Oracle Dynamic SQL וההצהרה המקבילה שלה ב-BigQuery:

Oracle	BigQuery
`EXECUTE IMMEDIATE sql_str [USING IN OUT [, ...]];`	`EXECUTE IMMEDIATE sql_expression [INTO variable[, ...]] [USING identifier[, ...]]; ;`

משפטי בקרה

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

Oracle	BigQuery
`IF condition THEN [if_statement_list] [ELSE else_statement_list ] END IF;`	`IF condition THEN [if_statement_list] [ELSE else_statement_list ] END IF;`
`SET SERVEROUTPUT ON; DECLARE x INTEGER DEFAULT 0; y INTEGER DEFAULT 0; BEGIN LOOP IF x>= 10 THEN EXIT; ELSIF x>= 5 THEN y := 5; END IF; x := x + 1; END LOOP; dbms_output.put_line(x\|\|','\|\|y); END; /`	`DECLARE x INT64 DEFAULT 0; DECLARE y INT64 DEFAULT 0; LOOP IF x>= 10 THEN LEAVE; ELSE IF x>= 5 THEN SET y = 5; END IF; END IF; SET x = x + 1; END LOOP; SELECT x,y;`
`LOOP sql_statement_list END LOOP;`	`LOOP sql_statement_list END LOOP;`
`WHILE boolean_expression DO sql_statement_list END WHILE;`	`WHILE boolean_expression DO sql_statement_list END WHILE;`
`FOR LOOP`	לא נעשה שימוש ב-`FOR LOOP` ב-BigQuery. משתמשים בהצהרות אחרות של `LOOP`.
`BREAK`	`BREAK`
`CONTINUE`	`CONTINUE`
`CONTINUE/EXIT WHEN`	שימוש ב-`CONTINUE` עם תנאי `IF`.
`GOTO`	ההצהרה `GOTO` לא קיימת ב-BigQuery. משתמשים בתנאי `IF`.

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

Oracle	BigQuery
`GATHER_STATS_JOB`	עדיין לא נעשה בו שימוש ב-BigQuery.
`LOCK TABLE table_name IN [SHARE/EXCLUSIVE] MODE NOWAIT;`	עדיין לא נעשה בו שימוש ב-BigQuery.
`Alter session set isolation_level=serializable; /` `SET TRANSACTION ...`	ב-BigQuery תמיד נעשה שימוש בבידוד של תמונת מצב. פרטים נוספים זמינים בקטע עקביות ורמת בידוד של טרנזקציה במאמר הזה.
`EXPLAIN PLAN ...`	לא בשימוש ב-BigQuery. תכונות דומות הן הסבר על תוכנית השאילתות בממשק המשתמש באינטרנט של BigQuery והקצאת משבצות, וגם רישום ביומן ביקורת ב-Stackdriver.
`SELECT * FROM DBA_[*];` (תצוגות Oracle DBA_/ALL_/V$)	`SELECT * FROM mydataset.INFORMATION_SCHEMA.TABLES;` מידע נוסף זמין במאמר מבוא ל-BigQuery INFORMATION_SCHEMA.
`SELECT * FROM GV$SESSION;` `SELECT * FROM V$ACTIVE_SESSION_HISTORY;`	ב-BigQuery אין את המושג המסורתי של סשן. אפשר להציג משימות של שאילתות בממשק המשתמש או לייצא יומני ביקורת של Stackdriver אל BigQuery ולנתח יומנים של BigQuery כדי לנתח משימות. מידע נוסף זמין במאמר הצגת פרטי המשרה.
`START TRANSACTION;` `LOCK TABLE table_A IN EXCLUSIVE MODE NOWAIT;` `DELETE FROM table_A;` `INSERT INTO table_A SELECT * FROM table_B;` `COMMIT;`	החלפת התוכן של טבלה בפלט של שאילתה שווה לעסקה. אפשר לעשות את זה באמצעות שאילתה או פעולת העתקה. שימוש בשאילתה: `bq query --replace --destination_table table_A 'SELECT * FROM table_B';` שימוש בעותק: `bq cp -f table_A table_B`

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

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

קודי שגיאה והודעות שגיאה

קודי השגיאה של Oracle שונים מקודי השגיאה של BigQuery. אם לוגיקת האפליקציה שלכם תופסת כרגע את השגיאות, נסו לסלק את מקור השגיאה, כי BigQuery לא מחזיר את אותם קודי שגיאה.

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

גם Oracle וגם BigQuery הן אטומיות – כלומר, הן תואמות ל-ACID ברמת כל שינוי בהרבה שורות. לדוגמה, פעולת MERGE היא אטומית, גם אם מוסיפים ומעדכנים כמה ערכים.

טרנזקציות

‫Oracle מספקת רמות בידוד של טרנזקציות מסוג read committed או serializable. יכול להיות שיהיו מצבים של קיפאון. הפעולות של Oracle insert append פועלות באופן עצמאי.

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

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

‫Oracle תומכת בביטול שינויים. מכיוון שאין גבולות ברורים לעסקאות ב-BigQuery, אין מושג של ביטול מפורש ב-BigQuery. הפתרונות העקיפים הם table decorators או שימוש ב-FOR SYSTEM_TIME AS OF.

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

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

הגבלה	Oracle	BigQuery
טבלאות לכל מסד נתונים	לא מוגבל	לא מוגבל
עמודות בכל טבלה	1000	10,000
גודל שורה מקסימלי	ללא הגבלה (תלוי בסוג העמודה)	‫100 MB
האורך של שמות העמודות והטבלאות	If v12.2>= 128 Bytes Else 30 Bytes	‫16,384 תווי Unicode
שורות לכל טבלה	ללא הגבלה	ללא הגבלה
אורך מקסימלי של בקשת SQL	ללא הגבלה	‫1 MB (אורך מקסימלי של שאילתת GoogleSQL לא פתורה) ‫12 MB (אורך מקסימלי של שאילתות מדור קודם ו-GoogleSQL שנפתרו) סטרימינג: ‫10 MB (מגבלת הגודל של בקשת HTTP) ‫10,000 (מספר השורות המקסימלי לכל בקשה)
גודל מקסימלי של בקשה ותגובה	ללא הגבלה	‫10 MB (בקשה) ו-10 GB (תגובה), או כמעט ללא הגבלה אם משתמשים בעימוד או ב-Cloud Storage API.
מספר מקסימלי של סשנים בו-זמניים	מוגבל על ידי הפרמטרים של הסשנים או התהליכים	‫100 שאילתות בו-זמניות (אפשר להגדיל את המכסה באמצעות הזמנת משבצות), 300 בקשות API בו-זמניות לכל משתמש.
מספר מקסימלי של טעינות בו-זמניות (מהירות)	מוגבל על ידי הפרמטרים של הסשנים או התהליכים	אין הגבלה על מספר המשימות שניתן להריץ בו-זמנית, המשימות מתווספות לתור. ‫100,000 משימות טעינה ליום לכל פרויקט.

מגבלות אחרות של Oracle Database כוללות מגבלות על סוגי נתונים, מגבלות על מסדי נתונים פיזיים, מגבלות על מסדי נתונים לוגיים ומגבלות על תהליכים וזמן ריצה.