יכול להיות שחלק מהמידע בדף הזה או כולו לא רלוונטי ל-Cloud de Confiance by S3NS. פרטים נוספים מופיעים במאמר מה ההבדל מ-Google Cloud.

Google uses AI technology to translate content into your preferred language. AI translations can contain errors.

מדריך לתרגום 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 תומך בשם אזור זמן ממסד נתונים של אזורי זמן ובסטייה מאזור הזמן UTC. ב-BigQuery, צריך לבצע המרה של אזור הזמן באופן ידני כדי להתאים לתכונה `TIMESTAMP WITH LOCAL TIME ZONE` של Oracle.
`TIMESTAMP(x)`	`TIMESTAMP`	‫BigQuery תומך בדיוק של מיקרו-שנייה (10^-6) בהשוואה ל-Oracle שתומך בדיוק בטווח של 0 עד 9. ‫BigQuery תומך בשם אזור זמן ממסד נתונים של אזורי זמן ובסטייה מאזור הזמן UTC. ב-BigQuery, צריך לבצע המרה של אזור הזמן באופן ידני כדי להתאים לתכונה `TIMESTAMP WITH LOCAL TIME ZONE` של Oracle.
`TIMESTAMP WITH TIME ZONE`	`TIMESTAMP`	‫BigQuery תומך בדיוק של מיקרו-שנייה (10^-6) בהשוואה ל-Oracle שתומך בדיוק בטווח של 0 עד 9. ‫BigQuery תומך בשם אזור זמן ממסד נתונים של אזורי זמן ובסטייה מאזור הזמן UTC. ב-BigQuery, צריך לבצע המרה של אזור הזמן באופן ידני כדי להתאים לתכונה `TIMESTAMP WITH LOCAL TIME ZONE` של Oracle.
`TIMESTAMP WITH LOCAL TIME ZONE`	`TIMESTAMP`	‫BigQuery תומך בדיוק של מיקרו-שנייה (10^-6) בהשוואה ל-Oracle שתומך בדיוק בטווח של 0 עד 9. ‫BigQuery תומך בשם אזור זמן ממסד נתונים של אזורי זמן ובסטייה מאזור הזמן 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 כשמוחזר ערך על ידי `SYSDATE or CURRENT_DATE`	ב-BigQuery יש פורמט נפרד `DATE` שתמיד מחזיר תאריך בפורמט ISO 8601. אי אפשר להשתמש ב-`DATE_FROM_UNIX_DATE` כי הוא מבוסס על 1970.
`CURRENT_DATE-3`	ערכי תאריך מיוצגים כמספרים שלמים. ‫Oracle תומך באופרטורים אריתמטיים לסוגי תאריכים.	לסוגי תאריכים, משתמשים ב-`DATE_ADD`() או ב-`DATE_SUB`(). ב-BigQuery משתמשים באופרטורים אריתמטיים לסוגי נתונים: `INT64`,‏ `NUMERIC` ו-`FLOAT64`.
`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.
`APPROX_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`	האופרטור bitwise not: ‏ ~
`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`	האופרטור bitwise not: ‏ ~
`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`	אפשר לבצע זיהוי וחישוב של דפוסים באמצעות ביטויים רגולריים ופונקציות מוגדרות על ידי המשתמש (UDF) ב-BigQuery
`MATCH_RECOGNIZE`	אפשר לבצע זיהוי וחישוב של דפוסים באמצעות ביטויים רגולריים ופונקציות מוגדרות על ידי המשתמש (UDF) ב-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. כדאי להשתמש בפונקציות מוגדרות על ידי המשתמש
`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 שונות זו מזו. כדי להשתמש ב-ML במסד הנתונים של Oracle, נדרשים חבילת ניתוח מתקדם ורישיונות. ‫Oracle משתמשת בחבילה DBMS_DATA_MINING ללמידת מכונה. כדי להמיר משימות של Oracle Data Miner, צריך לשכתב את הקוד כדי לעבוד עם התכונות של BigQuery. אתם יכולים לבחור מתוך המוצרים והתכונות של Google AI, כולל המוצרים והתכונות הבאים:

אתם יכולים להשתמש ב-BigQuery ML או בAgent Platform development tools כדי לפתח, לאמן ולבדוק מודלים של למידת מכונה.

בטבלה הבאה מוצגות פונקציות של 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 כדי להחליף את הפונקציונליות המרחבית. יש 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` דוח

אפשר לשלב פעולות INSERT, UPDATE ו-DELETE בהצהרת MERGE אחת ולבצע את הפעולות באופן אטומי.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, אפשר לעיין בדוגמאות לשימוש ב-CREATE TABLE ב-BigQuery.

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

עמודות זהות הוצגו בגרסה 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 tables are supported in 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 לכל שמות הטבלאות במערך הנתונים הזה כדי לציין בבירור שהטבלאות הן זמניות.
‫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 דינמיות

הצהרת ה-SQL הדינמית הבאה של Oracle וההצהרה המקבילה שלה ב-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 עוזר להבטיח בקרת בו-זמניות אופטימית (הראשון שמבצע שמירה מנצח) באמצעות בידוד snapshot, שבו שאילתה קוראת את הנתונים האחרונים שבוצעו לפני שהשאילתה מתחילה. הגישה הזו מבטיחה את אותה רמת עקביות ברמת השורה, ברמת השינוי וברמת השורות באותה פקודת DML, ועדיין מונעת מצבי קיפאון. במקרה של כמה הצהרות UPDATE שמופעלות על אותה טבלה, BigQuery עובר לבקרת בו-זמניות פסימית ומכניס לתור כמה הצהרות UPDATE, ומנסה שוב באופן אוטומטי במקרה של התנגשויות. INSERT אפשר להריץ הצהרות DML ומשימות טעינה במקביל ובאופן עצמאי כדי להוסיף נתונים לטבלאות.

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

‫Oracle תומכת בביטול שינויים. מכיוון שאין גבולות ברורים לעסקאות ב-BigQuery, אין מושג של ביטול מפורש ב-BigQuery. הפתרונות האפשריים הם קווי הפרדה בטבלה או שימוש ב-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 כוללות מגבלות על סוגי נתונים, מגבלות על מסדי נתונים פיזיים, מגבלות על מסדי נתונים לוגיים ומגבלות על תהליכים וזמן ריצה.