מדריך לתרגום SQL של Teradata

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

סוגי נתונים

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

הערה: מערכת Teradata תומכת בDEFAULT ובאילוצים אחרים, אבל הם לא בשימוש ב-BigQuery.

Teradata	BigQuery	הערות
INTEGER	INT64
SMALLINT	INT64
BYTEINT	INT64
BIGINT	INT64
DECIMAL	NUMERIC, DECIMAL BIGNUMERIC, BIGDECIMAL	משתמשים ב-NUMERIC (כינוי DECIMAL) ב-BigQuery כשהקנה מידה (הספרות אחרי הנקודה העשרונית) הוא ‎<= 9. משתמשים ב-BIGNUMERIC (כינוי BIGDECIMAL) של BigQuery כשערך הסולם גדול מ-9. אם אתם צריכים לאכוף גבולות (אילוצים) מותאמים אישית של ספרות או קנה מידה, אתם יכולים להשתמש בסוגי הנתונים העשרוניים עם פרמטרים של BigQuery. ‫Teradata מאפשרת להוסיף ערכים ברמת דיוק גבוהה יותר על ידי עיגול הערך המאוחסן, אבל היא שומרת על רמת הדיוק הגבוהה בחישובים. זה עלול להוביל ל  התנהגות לא צפויה של עיגול בהשוואה לתקן ANSI.
FLOAT	FLOAT64
NUMERIC	NUMERIC, DECIMAL BIGNUMERIC, BIGDECIMAL	משתמשים ב-NUMERIC (כינוי DECIMAL) ב-BigQuery כשהקנה מידה (הספרות אחרי הנקודה העשרונית) הוא ‎<= 9. משתמשים ב-BIGNUMERIC (כינוי BIGDECIMAL) של BigQuery כשערך הסולם גדול מ-9. אם אתם צריכים לאכוף גבולות (אילוצים) מותאמים אישית של ספרות או קנה מידה, אתם יכולים להשתמש בסוגי הנתונים העשרוניים עם פרמטרים של BigQuery. ‫Teradata מאפשרת להוסיף ערכים ברמת דיוק גבוהה יותר על ידי עיגול הערך המאוחסן, אבל היא שומרת על רמת הדיוק הגבוהה בחישובים. זה עלול להוביל ל  התנהגות לא צפויה של עיגול בהשוואה לתקן ANSI.
NUMBER	NUMERIC, DECIMAL BIGNUMERIC, BIGDECIMAL	משתמשים ב-NUMERIC (כינוי DECIMAL) ב-BigQuery כשהקנה מידה (הספרות אחרי הנקודה העשרונית) הוא ‎<= 9. משתמשים ב-BIGNUMERIC (כינוי BIGDECIMAL) של BigQuery כשערך הסולם גדול מ-9. אם אתם צריכים לאכוף גבולות (אילוצים) מותאמים אישית של ספרות או קנה מידה, אתם יכולים להשתמש בסוגי הנתונים העשרוניים עם פרמטרים של BigQuery. ‫Teradata מאפשרת להוסיף ערכים ברמת דיוק גבוהה יותר על ידי עיגול הערך המאוחסן, אבל היא שומרת על רמת הדיוק הגבוהה בחישובים. זה עלול להוביל ל  התנהגות לא צפויה של עיגול בהשוואה לתקן ANSI.
REAL	FLOAT64
CHAR/CHARACTER	STRING	אם אתם צריכים לאכוף אורך מקסימלי של מחרוזת תווים, אתם יכולים להשתמש בסוג הנתונים עם פרמטרים של STRING ב-BigQuery.
VARCHAR	STRING	אם אתם צריכים לאכוף אורך מקסימלי של מחרוזת תווים, אתם יכולים להשתמש בסוג הנתונים עם פרמטרים של STRING ב-BigQuery.
CLOB	STRING
JSON	JSON
BLOB	BYTES
BYTE	BYTES
VARBYTE	BYTES
DATE	DATE	‫BigQuery לא תומך בעיצוב מותאם אישית כמו ב-Teradata עם DataForm ב-SDF.
TIME	TIME
TIME WITH TIME ZONE	TIME	ב-Teradata, סוג הנתונים TIME מאוחסן ב-UTC, ואפשר להעביר היסט מ-UTC באמצעות התחביר WITH TIME ZONE. סוג הנתונים TIME ב-BigQuery מייצג שעה שלא תלויה בתאריך או באזור זמן.
TIMESTAMP	TIMESTAMP	לסוגי הנתונים ב-Teradata וב-BigQuery יש דיוק של מיקרו-שנייה (אבל Teradata תומך בשניות מעוברות, בעוד ש-BigQuery לא).TIMESTAMP סוגי הנתונים ב-Teradata וב-BigQuery משויכים בדרך כלל לאזור זמן UTC (פרטים).
TIMESTAMP WITH TIME ZONE	TIMESTAMP	אפשר להגדיר את TIMESTAMP ב-Teradata לאזור זמן אחר ברמת המערכת, ברמת המשתמש או ברמת העמודה (באמצעות WITH TIME ZONE). הסוג TIMESTAMP ב-BigQuery מניח UTC אם לא מציינים במפורש אזור זמן. חשוב לוודא שאתם מייצאים את פרטי אזור הזמן בצורה נכונה (אל תשרשרו ערך של DATE וערך של TIME בלי פרטי אזור הזמן) כדי שמערכת BigQuery תוכל להמיר אותו במהלך הייבוא. אפשר גם להמיר את נתוני אזור הזמן לשעון UTC לפני הייצוא. ב-BigQuery יש DATETIME להפשטה בין זמן אזרחי, שלא מוצג בו אזור זמן כשהוא מופק, לבין TIMESTAMP, שהוא נקודה מדויקת בזמן שתמיד מוצג בה אזור הזמן UTC.
ARRAY	ARRAY
MULTI-DIMENSIONAL ARRAY	ARRAY	ב-BigQuery, משתמשים במערך של מבנים, כאשר כל מבנה מכיל שדה מסוג ARRAY (פרטים נוספים זמינים במסמכי BigQuery).
INTERVAL HOUR	INT64
INTERVAL MINUTE	INT64
INTERVAL SECOND	INT64
INTERVAL DAY	INT64
INTERVAL MONTH	INT64
INTERVAL YEAR	INT64
PERIOD(DATE)	DATE, DATE	PERIOD(DATE) צריך להמיר לשתי עמודות DATE שמכילות את תאריך ההתחלה ואת תאריך הסיום, כדי שאפשר יהיה להשתמש בהן עם פונקציות חלון.
PERIOD(TIMESTAMP WITH TIME ZONE)	TIMESTAMP, TIMESTAMP
PERIOD(TIMESTAMP)	TIMESTAMP, TIMESTAMP
PERIOD(TIME)	TIME, TIME
PERIOD(TIME WITH TIME ZONE)	TIME, TIME
UDT	STRING
XML	STRING
TD_ANYTYPE	STRING

מידע נוסף על המרת טיפוסים מפורט בקטע הבא.

עיצוב סוג Teradata

ב-Teradata SQL יש קבוצה של פורמטים שמוגדרים כברירת מחדל להצגת ביטויים ונתוני עמודות, ולהמרות בין סוגי נתונים. לדוגמה, סוג הנתונים PERIOD(DATE) בפורמט INTEGERDATE מעוצב כ-YY/MM/DD כברירת מחדל. מומלץ להשתמש במצב ANSIDATE בכל הזדמנות כדי להבטיח תאימות ל-ANSI SQL, ולנצל את ההזדמנות הזו כדי לנקות פורמטים מדור קודם.

‫Teradata מאפשרת החלה אוטומטית של פורמטים מותאמים אישית באמצעות פסקה FORMAT, בלי לשנות את האחסון הבסיסי, או כמאפיין של סוג נתונים כשיוצרים טבלה באמצעות DDL, או בביטוי נגזר. לדוגמה, אם מציינים FORMAT 9.99, כל ערך FLOAT יעוגל לשתי ספרות. ב-BigQuery, צריך להמיר את הפונקציונליות הזו באמצעות הפונקציה ROUND().

הפונקציונליות הזו מחייבת טיפול במקרים מורכבים. לדוגמה, כשמחילים את פסקה FORMAT על עמודה NUMERIC, צריך להתחשב בכללי עיגול ועיצוב מיוחדים. אפשר להשתמש בסעיף FORMAT כדי להמיר באופן מרומז ערך של INTEGER epoch לפורמט DATE. או שציון של FORMAT X(6) בעמודה VARCHAR יגרום לחיתוך של ערך העמודה, ולכן תצטרכו להמיר אותו לפונקציה SUBSTR(). ההתנהגות הזו לא תואמת ל-ANSI SQL. לכן, אנחנו ממליצים לא להעביר פורמטים של עמודות ל-BigQuery.

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

מידע על פורמטי ברירת המחדל שמשמשים ב-Teradata SQL לכל סוג נתונים מופיע במסמכי התיעוד בנושא פורמט ברירת המחדל של Teradata.

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

בטבלה הבאה מסוכמים ההבדלים בין רכיבי הפורמט של חותמת הזמן והתאריך ב-Teradata SQL וב-GoogleSQL.

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

פורמט Teradata	תיאור של Teradata	BigQuery
CURRENT_TIMESTAMP CURRENT_TIME	יכול להיות שמידע על TIME ו-TIMESTAMP ב-Teradata יכלול פרטים שונים על אזור הזמן, שמוגדר באמצעות WITH TIME ZONE.	אם אפשר, כדאי להשתמש בפורמט ISO‏ CURRENT_TIMESTAMP(). עם זאת, פורמט הפלט תמיד מציג את אזור הזמן UTC. (מבחינה פנימית, אין אזור זמן ב-BigQuery). חשוב לשים לב לפרטים הבאים לגבי ההבדלים בפורמט ISO. הפורמט של DATETIME מבוסס על המוסכמות של ערוץ הפלט. בכלי שורת הפקודה של BigQuery ובמסוף BigQuery, הפורמט הוא T לפי RFC 3339. אבל ב-Python וב-Java JDBC, משתמשים ברווח כמפריד. אם רוצים להשתמש בפורמט מפורש, משתמשים ב-FORMAT_DATETIME(), שמבצע המרה מפורשת למחרוזת. לדוגמה, הביטוי הבא תמיד מחזיר מפריד רווח: CAST(CURRENT_DATETIME() AS STRING) ‫Teradata תומכת במילת המפתח DEFAULT בעמודות TIME כדי להגדיר את השעה הנוכחית (חותמת זמן). אין שימוש במילת המפתח הזו ב-BigQuery.
CURRENT_DATE	תאריכים מאוחסנים ב-Teradata כערכים מסוג INT64 באמצעות הנוסחה הבאה: (YEAR - 1900) * 10000 + (MONTH * 100) + DAY אפשר לעצב תאריכים כמספרים שלמים.	ב-BigQuery יש פורמט נפרד DATE שתמיד מחזיר תאריך בפורמט ISO 8601. אי אפשר להשתמש ב-DATE_FROM_UNIX_DATE כי הוא מבוסס על 1970. ‫Teradata תומכת במילת המפתח DEFAULT בעמודות DATE כדי להגדיר את התאריך הנוכחי. המילה הזו לא נמצאת בשימוש ב-BigQuery.
CURRENT_DATE-3	ערכי תאריך מיוצגים כמספרים שלמים. ‫Teradata תומכת באופרטורים אריתמטיים לסוגי תאריכים.	לסוגי תאריכים, משתמשים ב-DATE_ADD() או ב-DATE_SUB(). ב-BigQuery נעשה שימוש באופרטורים אריתמטיים עבור סוגי הנתונים: ‫INT64, NUMERIC ו-FLOAT64.
SYS_CALENDAR.CALENDAR	‫Teradata מספקת תצוגה לפעולות ביומן כדי להרחיב את הפעולות מעבר למספרים שלמים.	לא בשימוש ב-BigQuery.
SET SESSION DATEFORM=ANSIDATE	מגדירים את פורמט התאריך של הסשן או המערכת ל-ANSI ‏ (ISO 8601).	ב-BigQuery תמיד משתמשים בפורמט ISO 8601, לכן חשוב להמיר את התאריכים והשעות ב-Teradata.

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

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

SELECT דוחות

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

Teradata		BigQuery
SEL		המרה ל-SELECT. ב-BigQuery לא נעשה שימוש בקיצור SEL.
SELECT   (subquery) AS flag,   CASE WHEN flag = 1 THEN ...		ב-BigQuery, עמודות לא יכולות להפנות לפלט של עמודות אחרות שמוגדרות באותה רשימת בחירה. עדיף להעביר שאילתת משנה אל פסקה WITH. WITH flags AS (   subquery ), SELECT   CASE WHEN flags.flag = 1 THEN ...
SELECT * FROM table WHERE A LIKE ANY ('string1', 'string2')		ב-BigQuery לא נעשה שימוש בANY predicate לוגי. אפשר להשיג את אותה הפונקציונליות באמצעות כמה OR אופרטורים: SELECT * FROM table WHERE col LIKE 'string1' OR       col LIKE 'string2' במקרה הזה, גם ההשוואה בין המחרוזות שונה. אופרטורים להשוואה
SELECT TOP 10 * FROM table		ב-BigQuery, בסוף שאילתה משתמשים ב-LIMIT במקום ב-TOP n אחרי מילת המפתח SELECT.

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

בטבלה הבאה מוצגים אופרטורים להשוואה ב-Teradata שספציפיים ל-Teradata וצריך להמיר אותם לאופרטורים שתואמים ל-ANSI SQL:2011 שמשמשים ב-BigQuery.

מידע על אופרטורים ב-BigQuery זמין בקטע אופרטורים במאמרי העזרה של BigQuery.

Teradata	BigQuery	הערות
exp EQ exp2 exp IN (exp2, exp3)	exp = exp2 exp IN (exp2, exp3) כדי לשמור על הסמנטיקה של NOT CASESPECIFIC שאינה ANSI, אפשר להשתמש ב- RTRIM(UPPER(exp)) = RTRIM(UPPER(exp2))	כשמשווים מחרוזות לשוויון, יכול להיות ש-Teradata יתעלם מרווחים לבנים בסוף המחרוזת, אבל BigQuery יתייחס אליהם כחלק מהמחרוזת. לדוגמה, 'xyz'=' xyz' הוא TRUE ב-Teradata אבל FALSE ב-BigQuery. ב-Teradata יש גם מאפיין עמודה NOT CASESPECIFIC שמורה למערכת להתעלם מהאותיות הרישיות והקטנות כשמשווים בין שני מחרוזות. ההשוואה בין מחרוזות ב-BigQuery תמיד תלויה באותיות רישיות. לדוגמה, 'xYz' = 'xyz' הוא TRUE ב-Teradata אבל FALSE ב-BigQuery.
exp LE exp2	exp <= exp2
exp LT exp2	exp < exp2
exp NE exp2	exp <> exp2 exp != exp2
exp GE exp2	exp >= exp2
exp GT exp2	exp > exp2

JOIN תנאים

‫BigQuery ו-Teradata תומכים באותם תנאים של JOIN, ON ו-USING. בטבלה הבאה מפורטים כמה הבדלים קטנים.

Teradata	BigQuery	הערות
FROM A JOIN B ON A.date > B.start_date AND A.date < B.end_date	FROM A LEFT OUTER JOIN B ON A.date > B.start_date AND A.date < B.end_date	‫BigQuery תומך בסעיפי אי-שוויון JOIN לכל הצטרפות פנימית או אם מצוין לפחות תנאי שוויון אחד (=). אבל לא רק תנאי אי-שוויון אחד (= ו-<) ב-OUTER JOIN. מבנים כאלה משמשים לפעמים להרצת שאילתות על טווחי תאריכים או מספרים שלמים. ‫BigQuery מונע ממשתמשים ליצור בטעות צירופים גדולים.
FROM A, B ON A.id = B.id	FROM A JOIN B ON A.id = B.id	שימוש בפסיק בין טבלאות ב-Teradata שווה ל-INNER JOIN, וב-BigQuery הוא שווה ל-CROSS JOIN (מכפלה קרטזית). הפסיק ב-BigQuery ב-SQL מדור קודם נחשב ל-UNION, ולכן מומלץ להגדיר את הפעולה באופן מפורש כדי למנוע בלבול.
FROM A JOIN B ON (COALESCE(A.id , 0) = COALESCE(B.id, 0))	FROM A JOIN B ON (COALESCE(A.id , 0) = COALESCE(B.id, 0))	אין הבדל בפונקציות סקלריות (קבועות).
FROM A JOIN B ON A.id = (SELECT MAX(B.id) FROM B)	FROM A JOIN (SELECT MAX(B.id) FROM B) B1 ON A.id = B1.id	ב-BigQuery, משתמשים לא יכולים להשתמש בשאילתות משנה, בשאילתות משנה מתואמות או בצבירות בפרדיקטים של צירוף. כך BigQuery יכול לבצע שאילתות במקביל.

המרת סוגים (type conversion) והמרת טיפוסים (casting)

ל-BigQuery יש פחות סוגי נתונים מאשר ל-Teradata, אבל הם רחבים יותר, ולכן BigQuery צריך להיות מחמיר יותר בהמרת סוגי נתונים.

Teradata	BigQuery	הערות
exp EQ exp2 exp IN (exp2, exp3)	exp = exp2 exp IN (exp2, exp3) כדי לשמור על הסמנטיקה של NOT CASESPECIFIC שאינה ANSI, אפשר להשתמש ב- RTRIM(UPPER(exp)) = RTRIM(UPPER(exp2))	כשמשווים מחרוזות לשוויון, יכול להיות ש-Teradata יתעלם מרווחים לבנים בסוף המחרוזת, אבל BigQuery יתייחס אליהם כחלק מהמחרוזת. לדוגמה, 'xyz'=' xyz' הוא TRUE ב-Teradata אבל FALSE ב-BigQuery. ב-Teradata יש גם מאפיין של עמודה NOT CASESPECIFIC שמורה ל-Teradata להתעלם מהאותיות הקטנות והגדולות כשמשווים בין שני מחרוזות. ההשוואה בין מחרוזות ב-BigQuery תמיד תלויה באותיות רישיות. לדוגמה, 'xYz' = 'xyz' הוא TRUE ב-Teradata אבל FALSE ב-BigQuery.
CAST(long_varchar_column AS CHAR(6))	LPAD(long_varchar_column, 6)	לפעמים משתמשים בהמרת עמודת תווים ב-Teradata כדרך לא סטנדרטית ולא אופטימלית ליצירת מחרוזת משנה עם ריפוד.
CAST(92617 AS TIME) 92617 (FORMAT '99:99:99')	PARSE_TIME("%k%M%S", CAST(92617 AS STRING))	ב-Teradata מתבצעות הרבה המרות סוגים מרומזות ועיגולים בהשוואה ל-BigQuery, שבו בדרך כלל יש הקפדה רבה יותר על תקני ANSI. (בדוגמה הזו מוחזרת השעה 09:26:17)
CAST(48.5 (FORMAT 'zz') AS FLOAT)	CAST(SUBSTR(CAST(48.5 AS STRING), 0, 2) AS FLOAT64)	כשמחילים פורמטים כמו מטבעות על נתונים מסוג נקודה צפה ומספרי, יכול להיות שיהיה צורך בכללי עיגול מיוחדים. ‫ (בדוגמה הזו מוחזר הערך 48)

הפעלת Cast של FLOAT/DECIMAL אל INT

ב-Teradata נעשה שימוש באלגוריתמים של גאוס ובנקאי כדי לעגל מספרים. ב-BigQuery, משתמשים בפונקציה ROUND_HALF_EVEN RoundingMode:

round(CAST(2.5 as Numeric),0, 'ROUND_HALF_EVEN')

הפעלת Cast של STRING אל NUMERIC או BIGNUMERIC

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

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

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

QUALIFY, ROWS סעיפים

הסעיף QUALIFY ב-Teradata מאפשר לסנן תוצאות של פונקציות חלון. אפשר גם להשתמש בROWS ביטוי כדי לבצע את אותה המשימה. הן פועלות באופן דומה לתנאי HAVING של פסקה GROUP, ומגבילות את הפלט של מה שנקרא ב-BigQuery פונקציות חלון.

Teradata	BigQuery
SELECT col1, col2 FROM table QUALIFY ROW_NUMBER() OVER (PARTITION BY col1 ORDER BY col2) = 1;	הפסוקית QUALIFY של Teradata עם פונקציית חלון כמו ROW_NUMBER(), SUM(), COUNT() ועם OVER PARTITION BY מבוטאת ב-BigQuery כפסוקית WHERE בשאילתת משנה שמכילה ערך ניתוח. ‫ שימוש ב-ROW_NUMBER(): SELECT col1, col2 FROM (   SELECT col1, col2,   ROW_NUMBER() OVER (PARTITION BY col1 ORDER BY col2) RN   FROM table ) WHERE RN = 1; שימוש ב-ARRAY_AGG, שתומך במחיצות גדולות יותר: SELECT   result.* FROM (   SELECT     ARRAY_AGG(table ORDER BY table.col2       DESC LIMIT 1)[OFFSET(0)]   FROM table   GROUP BY col1 ) AS result;
SELECT col1, col2 FROM table AVG(col1) OVER (PARTITION BY col1 ORDER BY col2 ROWS BETWEEN 2 PRECEDING AND CURRENT ROW);	SELECT col1, col2 FROM table AVG(col1) OVER (PARTITION BY col1 ORDER BY col2 RANGE BETWEEN 2 PRECEDING AND CURRENT ROW); ב-BigQuery, אפשר להשתמש ב-RANGE וב-ROWS במשפט של מסגרת החלון. עם זאת, אפשר להשתמש בסעיפי חלון רק עם פונקציות חלון כמו AVG(), ולא עם פונקציות מספור כמו ROW_NUMBER().
SELECT col1, col2 FROM table QUALIFY ROW_NUMBER() OVER (PARTITION BY col1 ORDER BY col2) = 1;	SELECT col1, col2 FROM Dataset-name.table QUALIFY row_number() OVER (PARTITION BY upper(a.col1) ORDER BY upper(a.col2)) = 1

מילת מפתח אחת (NORMALIZE)

‫Teradata מספקת את מילת המפתח NORMALIZE עבור סעיפי SELECT כדי למזג תקופות או מרווחי זמן חופפים לתקופה או למרווח זמן יחידים שכוללים את כל הערכים של התקופות הנפרדות.

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

Teradata

BigQuery

SELECT NORMALIZE     client_id,     item_sid,     BEGIN(period) AS min_date,     END(period) AS max_date,   FROM     table;

SELECT   t.client_id,   t.item_sid,   t.min_date,   MAX(t.dwh_valid_to) AS max_date FROM (   SELECT     d1.client_id,     d1.item_sid,     d1.dwh_valid_to AS dwh_valid_to,     MIN(d2.dwh_valid_from) AS min_date   FROM     table d1   LEFT JOIN     table d2   ON     d1.client_id = d2.client_id     AND d1.item_sid = d2.item_sid     AND d1.dwh_valid_to >= d2.dwh_valid_from     AND d1.dwh_valid_from < = d2.dwh_valid_to   GROUP BY     d1.client_id,     d1.item_sid,     d1.dwh_valid_to ) t GROUP BY   t.client_id,   t.item_sid,   t.min_date;

פונקציות

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

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

בטבלה הבאה מפורטות פונקציות צבירה נפוצות של Teradata, פונקציות צבירה סטטיסטיות ופונקציות צבירה משוערות, והפונקציות המקבילות שלהן ב-BigQuery. ‫BigQuery מציע את פונקציות הצבירה הנוספות הבאות:

• ANY_VALUE
• APPROX_COUNT_DISTINCT
• APPROX_QUANTILES
• APPROX_TOP_COUNT
• APPROX_TOP_SUM
• COUNTIF
• LOGICAL_AND
• LOGICAL_OR
• STRING_AGG

Teradata	BigQuery
AVG	AVG הערה: כשמחשבים את הממוצע של INT ערכים, BigQuery מספק תוצאות משוערות.
BITAND	BIT_AND
BITNOT	אופרטור השלילה הבינארית (~)
BITOR	BIT_OR
BITXOR	BIT_XOR
CORR	CORR
COUNT	COUNT
COVAR_POP	COVAR_POP
COVAR_SAMP	COVAR_SAMP
MAX	MAX
MIN	MIN
REGR_AVGX	AVG(   IF(dep_var_expression is NULL      OR ind_var_expression is NULL,      NULL, ind_var_expression) )
REGR_AVGY	AVG(   IF(dep_var_expression is NULL      OR ind_var_expression is NULL,      NULL, dep_var_expression) )
REGR_COUNT	SUM(   IF(dep_var_expression is NULL      OR ind_var_expression is NULL,      NULL, 1) )
REGR_INTERCEPT	AVG(dep_var_expression) - AVG(ind_var_expression) * (COVAR_SAMP(ind_var_expression,               dep_var_expression)    / VARIANCE(ind_var_expression))
REGR_R2	(COUNT(dep_var_expression)*  SUM(ind_var_expression * dep_var_expression) -  SUM(dep_var_expression) * SUM(ind_var_expression)) / SQRT(      (COUNT(ind_var_expression)*       SUM(POWER(ind_var_expression, 2))*       POWER(SUM(ind_var_expression),2))*      (COUNT(dep_var_expression)*       SUM(POWER(dep_var_expression, 2))*       POWER(SUM(dep_var_expression), 2)))
REGR_SLOPE	- COVAR_SAMP(ind_var_expression,             dep_var_expression) / VARIANCE(ind_var_expression)
REGR_SXX	SUM(POWER(ind_var_expression, 2)) - COUNT(ind_var_expression) *   POWER(AVG(ind_var_expression),2)
REGR_SXY	SUM(ind_var_expression * dep_var_expression) - COUNT(ind_var_expression)   * AVG(ind_var_expression) * AVG(dep_var_expression)
REGR_SYY	SUM(POWER(dep_var_expression, 2)) - COUNT(dep_var_expression)   * POWER(AVG(dep_var_expression),2)
SKEW	פונקציה בהגדרת המשתמש (UDF) מותאמת אישית.
STDDEV_POP	STDDEV_POP
STDDEV_SAMP	STDDEV_SAMP, STDDEV
SUM	SUM
VAR_POP	VAR_POP
VAR_SAMP	VAR_SAMP, VARIANCE

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

בטבלה הבאה מפורטות פונקציות אנליטיות נפוצות של Teradata ופונקציות אנליטיות מצטברות, והפונקציות המקבילות שלהן ב-BigQuery. ‫BigQuery מציע את הפונקציות הנוספות הבאות:

• ANY_VALUE
• AVG
• COUNTIF
• LAG
• LEAD
• LOGICAL_AND
• LOGICAL_OR
• NTH_VALUE
• NTILE
• STRING_AGG

Teradata	BigQuery
ARRAY_AGG	ARRAY_AGG
ARRAY_CONCAT, (|| operator)	ARRAY_CONCAT_AGG, (|| operator)
BITAND	BIT_AND
BITNOT	אופרטור השלילה הבינארית (~)
BITOR	BIT_OR
BITXOR	BIT_XOR
CORR	CORR
COUNT	COUNT
COVAR_POP	COVAR_POP
COVAR_SAMP	COVAR_SAMP
CUME_DIST	CUME_DIST
DENSE_RANK (ANSI)	DENSE_RANK
FIRST_VALUE	FIRST_VALUE
LAST_VALUE	LAST_VALUE
MAX	MAX
MIN	MIN
PERCENT_RANK	PERCENT_RANK
PERCENTILE_CONT, PERCENTILE_DISC	PERCENTILE_CONT, PERCENTILE_DISC
QUANTILE	NTILE
RANK (ANSI)	RANK
ROW_NUMBER	ROW_NUMBER
STDDEV_POP	STDDEV_POP
STDDEV_SAMP	STDDEV_SAMP, STDDEV
SUM	SUM
VAR_POP	VAR_POP
VAR_SAMP	VAR_SAMP, VARIANCE

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

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

• CURRENT_DATETIME
• DATE_ADD
• DATE_DIFF
• DATE_FROM_UNIX_DATE
• DATE_SUB
• DATE_TRUNC
• DATETIME
• DATETIME_ADD
• DATETIME_DIFF
• DATETIME_SUB
• DATETIME_TRUNC
• PARSE_DATE
• PARSE_DATETIME
• PARSE_TIME
• PARSE_TIMESTAMP
• STRING
• TIME
• TIME_ADD
• TIME_DIFF
• TIME_SUB
• TIME_TRUNC
• TIMESTAMP
• TIMESTAMP_ADD
• TIMESTAMP_DIFF
• TIMESTAMP_MICROS
• TIMESTAMP_MILLIS
• TIMESTAMP_SECONDS
• TIMESTAMP_SUB
• TIMESTAMP_TRUNC
• UNIX_DATE
• UNIX_MICROS
• UNIX_MILLIS
• UNIX_SECONDS

Teradata	BigQuery
ADD_MONTHS	DATE_ADD, TIMESTAMP_ADD
CURRENT_DATE	CURRENT_DATE
CURRENT_TIME	CURRENT_TIME
CURRENT_TIMESTAMP	CURRENT_TIMESTAMP
DATE + k	DATE_ADD(date_expression, INTERVAL k DAY)
DATE - k	DATE_SUB(date_expression, INTERVAL k DAY)
EXTRACT	EXTRACT(DATE), EXTRACT(TIMESTAMP)
	FORMAT_DATE
	FORMAT_DATETIME
	FORMAT_TIME
	FORMAT_TIMESTAMP
LAST_DAY	LAST_DAY הערה: הפונקציה הזו תומכת בביטויי קלט מסוג DATE וגם מסוג DATETIME.
MONTHS_BETWEEN	DATE_DIFF(date_expression, date_expression, MONTH)
NEXT_DAY	DATE_ADD(   DATE_TRUNC(     date_expression,     WEEK(day_value)   ),   INTERVAL 1 WEEK )
OADD_MONTHS	DATE_SUB(   DATE_TRUNC(     DATE_ADD(       date_expression,       INTERVAL num_months MONTH     ),     MONTH   ),   INTERVAL 1 DAY )
td_day_of_month	EXTRACT(DAY FROM date_expression) EXTRACT(DAY FROM timestamp_expression)
td_day_of_week	EXTRACT(DAYOFWEEK FROM date_expression) EXTRACT(DAYOFWEEK FROM timestamp_expression)
td_day_of_year	EXTRACT(DAYOFYEAR FROM date_expression) EXTRACT(DAYOFYEAR FROM timestamp_expression)
td_friday	DATE_TRUNC(   date_expression,   WEEK(FRIDAY) )
td_monday	DATE_TRUNC(   date_expression,   WEEK(MONDAY) )
td_month_begin	DATE_TRUNC(date_expression, MONTH)
td_month_end	DATE_SUB(   DATE_TRUNC(     DATE_ADD(       date_expression,       INTERVAL 1 MONTH     ),     MONTH   ),   INTERVAL 1 DAY )
td_month_of_calendar	(EXTRACT(YEAR FROM date_expression) - 1900) * 12 + EXTRACT(MONTH FROM date_expression)
td_month_of_quarter	EXTRACT(MONTH FROM date_expression) - ((EXTRACT(QUARTER FROM date_expression) - 1) * 3)
td_month_of_year	EXTRACT(MONTH FROM date_expression) EXTRACT(MONTH FROM timestamp_expression)
td_quarter_begin	DATE_TRUNC(date_expression, QUARTER)
td_quarter_end	DATE_SUB(   DATE_TRUNC(     DATE_ADD(       date_expression,       INTERVAL 1 QUARTER     ),     QUARTER   ),   INTERVAL 1 DAY )
td_quarter_of_calendar	(EXTRACT(YEAR FROM date_expression) - 1900) * 4 + EXTRACT(QUARTER FROM date_expression)
td_quarter_of_year	EXTRACT(QUARTER FROM date_expression) EXTRACT(QUARTER FROM timestamp_expression)
td_saturday	DATE_TRUNC(   date_expression,   WEEK(SATURDAY) )
td_sunday	DATE_TRUNC(   date_expression,   WEEK(SUNDAY) )
td_thursday	DATE_TRUNC(   date_expression,   WEEK(THURSDAY) )
td_tuesday	DATE_TRUNC(   date_expression,   WEEK(TUESDAY) )
td_wednesday	DATE_TRUNC(   date_expression,   WEEK(WEDNESDAY) )
td_week_begin	DATE_TRUNC(date_expression, WEEK)
td_week_end	DATE_SUB(   DATE_TRUNC(     DATE_ADD(       date_expression,       INTERVAL 1 WEEK     ),     WEEK   ),   INTERVAL 1 DAY )
td_week_of_calendar	(EXTRACT(YEAR FROM date_expression) - 1900) * 52 + EXTRACT(WEEK FROM date_expression)
td_week_of_month	EXTRACT(WEEK FROM date_expression) - EXTRACT(WEEK FROM DATE_TRUNC(date_expression, MONTH))
td_week_of_year	EXTRACT(WEEK FROM date_expression) EXTRACT(WEEK FROM timestamp_expression)
td_weekday_of_month	CAST(   CEIL(     EXTRACT(DAY FROM date_expression)     / 7   ) AS INT64 )
td_year_begin	DATE_TRUNC(date_expression, YEAR)
td_year_end	DATE_SUB(   DATE_TRUNC(     DATE_ADD(       date_expression,       INTERVAL 1 YEAR     ),     YEAR   ),   INTERVAL 1 DAY )
td_year_of_calendar	EXTRACT(YEAR FROM date_expression)
TO_DATE	PARSE_DATE
TO_TIMESTAMP	PARSE_TIMESTAMP
TO_TIMESTAMP_TZ	PARSE_TIMESTAMP

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

בטבלה הבאה מפורטות פונקציות מחרוזת ב-Teradata והפונקציות המקבילות שלהן ב-BigQuery. ‫BigQuery מציע את הפונקציות הנוספות הבאות למחרוזות:

• BYTE_LENGTH
• CODE_POINTS_TO_BYTES
• ENDS_WITH
• FROM_BASE32
• FROM_BASE64
• FROM_HEX
• NORMALIZE
• NORMALIZE_AND_CASEFOLD
• REGEXP_CONTAINS
• REGEXP_EXTRACT
• REGEXP_EXTRACT_ALL
• REPEAT
• REPLACE
• SAFE_CONVERT_BYTES_TO_STRING
• SPLIT
• STARTS_WITH
• STRPOS
• TO_BASE32
• TO_BASE64
• TO_CODE_POINTS
• TO_HEX

Teradata	BigQuery
ASCII	TO_CODE_POINTS(string_expression)[OFFSET(0)]
CHAR2HEXINT	TO_HEX
CHARACTER LENGTH	CHAR_LENGTH
CHARACTER LENGTH	CHARACTER_LENGTH
CHR	CODE_POINTS_TO_STRING(   [mod(numeric_expression, 256)] )
CONCAT, (|| operator)	CONCAT, (|| operator)
CSV	פונקציה בהגדרת המשתמש (UDF) מותאמת אישית.
CSVLD	פונקציה בהגדרת המשתמש (UDF) מותאמת אישית.
FORMAT	FORMAT
INDEX	STRPOS(string, substring)
INITCAP	INITCAP
INSTR	פונקציה בהגדרת המשתמש (UDF) מותאמת אישית.
LEFT	SUBSTR(source_string, 1, length)
LENGTH	LENGTH
LOWER	LOWER
LPAD	LPAD
LTRIM	LTRIM
NGRAM	פונקציה בהגדרת המשתמש (UDF) מותאמת אישית.
NVP	פונקציה בהגדרת המשתמש (UDF) מותאמת אישית.
OREPLACE	REPLACE
OTRANSLATE	פונקציה בהגדרת המשתמש (UDF) מותאמת אישית.
POSITION	STRPOS(string, substring)
REGEXP_INSTR	STRPOS(source_string, REGEXP_EXTRACT(source_string, regexp_string)) הערה: הפונקציה מחזירה את המופע הראשון.
REGEXP_REPLACE	REGEXP_REPLACE
REGEXP_SIMILAR	IF(REGEXP_CONTAINS,1,0)
REGEXP_SUBSTR	REGEXP_EXTRACT, REGEXP_EXTRACT_ALL
REGEXP_SPLIT_TO_TABLE	פונקציה בהגדרת המשתמש (UDF) מותאמת אישית.
REVERSE	REVERSE
RIGHT	SUBSTR(source_string, -1, length)
RPAD	RPAD
RTRIM	RTRIM
STRTOK הערה: כל תו בארגומנט של מחרוזת התווים המפרידים נחשב לתו מפריד נפרד. תו המפריד שמוגדר כברירת מחדל הוא רווח.	SPLIT(instring, delimiter)[ORDINAL(tokennum)] הערה: כל הארגומנט של המחרוזת delimiter משמש כמפריד יחיד. ברירת המחדל של תו המפריד היא פסיק.
STRTOK_SPLIT_TO_TABLE	פונקציה בהגדרת המשתמש מותאמת אישית
SUBSTRING, SUBSTR	SUBSTR
TRIM	TRIM
UPPER	UPPER

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

בטבלה הבאה ממופות פונקציות מתמטיות של Teradata לפונקציות המקבילות שלהן ב-BigQuery. ‫BigQuery מציע את הפונקציות המתמטיות הנוספות הבאות:

• DIV
• IEEE_DIVIDE
• IS_INF
• IS_NAN
• LOG10
• SAFE_DIVIDE

Teradata	BigQuery
ABS	ABS
ACOS	ACOS
ACOSH	ACOSH
ASIN	ASIN
ASINH	ASINH
ATAN	ATAN
ATAN2	ATAN2
ATANH	ATANH
CEILING	CEIL
CEILING	CEILING
COS	COS
COSH	COSH
EXP	EXP
FLOOR	FLOOR
GREATEST	GREATEST
LEAST	LEAST
LN	LN
LOG	LOG
MOD (אופרטור %)	MOD
NULLIFZERO	NULLIF(expression, 0)
POWER (אופרטור **)	POWER, POW
RANDOM	RAND
ROUND	ROUND
SIGN	SIGN
SIN	SIN
SINH	SINH
SQRT	SQRT
TAN	TAN
TANH	TANH
TRUNC	TRUNC
ZEROIFNULL	IFNULL(expression, 0), COALESCE(expression, 0)

פונקציות עיגול

ב-Teradata נעשה שימוש באלגוריתמים של גאוס ובנקאי כדי לעגל מספרים. ב-BigQuery, משתמשים בפונקציה ROUND_HALF_EVEN RoundingMode:

-- Teradata syntax
round(3.45,1)

-- BigQuery syntax
round(CAST(3.45 as Numeric),1, 'ROUND_HALF_EVEN')

תחביר DML

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

INSERT דוחות

רוב ההצהרות של Teradata INSERT תואמות ל-BigQuery. בטבלה הבאה מוצגים יוצאים מן הכלל.

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

Teradata	BigQuery
INSERT INTO table VALUES (...);	INSERT INTO table (...) VALUES (...); ב-Teradata יש מילת מפתח 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 INTO table VALUES (1,2,3),                          (4,5,6),                          (7,8,9); ב-Teradata יש מושג שנקרא בקשה עם כמה הצהרות (MSR), ששולחת כמה INSERTהצהרות בכל פעם. ב-BigQuery, לא מומלץ לעשות את זה בגלל גבולות העסקה המרומזים בין ההצהרות. במקום זאת, צריך להשתמש ב-multi-value INSERT. ‫BigQuery מאפשרת הצהרות INSERT בו-זמניות, אבל יכול להיות שהיא תכניס אותן לתור UPDATE. כדי לשפר את הביצועים, כדאי לנסות את הגישות הבאות: לשלב כמה שורות בהצהרת INSERT אחת, במקום שורה אחת לכל פעולת INSERT. לשלב כמה פקודות DML (כולל INSERT) באמצעות פקודת MERGE. כדאי להשתמש ב-CREATE TABLE ... AS SELECT כדי ליצור טבלאות חדשות ולאכלס אותן במקום ב-UPDATE או ב-DELETE, במיוחד כשמבצעים שאילתות על שדות מחולקים או כשמשחזרים או מבטלים שינויים.

UPDATE דוחות

רוב ההצהרות של Teradata UPDATE תואמות ל-BigQuery, למעט הפריטים הבאים:

• כשמשתמשים בפסוקית FROM, הסדר של הפסוקיות FROM ו-SET מתהפך ב-Teradata וב-BigQuery.
• ב-GoogleSQL, כל הצהרת UPDATE חייבת לכלול את מילת המפתח WHERE, ואחריה תנאי. כדי לעדכן את כל השורות בטבלה, משתמשים ב-WHERE true.

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

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

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

Teradata		BigQuery
UPDATE table_A FROM table_A, table_B SET   y = table_B.y,   z = table_B.z + 1 WHERE table_A.x = table_B.x   AND table_A.y IS NULL;		UPDATE table_A SET   y = table_B.y,   z = table_B.z + 1 FROM table_B WHERE table_A.x = table_B.x   AND table_A.y IS NULL;
UPDATE table alias SET x = x + 1 WHERE f(x) IN (0, 1);		UPDATE table SET x = x + 1 WHERE f(x) IN (0, 1);
UPDATE table_A FROM table_A, table_B, B SET z = table_B.z WHERE table_A.x = table_B.x   AND table_A.y = table_B.y;		UPDATE table_A SET z = table_B.z FROM table_B WHERE table_A.x = table_B.x   AND table_A.y = table_B.y;

DELETE ודוחות TRUNCATE

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

ב-BigQuery, להצהרת DELETE חייב להיות סעיף WHERE. כדי למחוק את כל השורות בטבלה (חיתוך), משתמשים ב-WHERE true. כדי להאיץ את פעולות החיתוך בטבלאות גדולות מאוד, מומלץ להשתמש בהצהרת CREATE OR REPLACE TABLE ... AS SELECT, ולהשתמש ב-LIMIT 0 באותה טבלה כדי להחליף את עצמה. עם זאת, חשוב להוסיף ידנית מידע על חלוקה למחיצות ועל אשכולות כשמשתמשים בו.

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

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

Teradata	BigQuery
BEGIN TRANSACTION; LOCKING TABLE table_A FOR EXCLUSIVE; DELETE FROM table_A; INSERT INTO table_A SELECT * FROM table_B; END TRANSACTION;	החלפת התוכן של טבלה בפלט של שאילתה שווה לעסקה. אפשר לעשות את זה באמצעות פעולת שאילתה או פעולת העתקה. שימוש בפעולת שאילתה: bq query --replace --destination_table table_A 'SELECT * FROM table_B'; שימוש בפעולת העתקה: bq cp -f table_A table_B
DELETE database.table ALL;	DELETE FROM table WHERE TRUE; או דרך מהירה יותר לטבלאות גדולות מאוד: CREATE OR REPLACE table AS SELECT * FROM table LIMIT 0;

MERGE דוחות

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

הפעולה MERGE של Teradata מוגבלת להתאמת מפתחות ראשיים בתוך מעבד מודול גישה (AMP) אחד. לעומת זאת, ב-BigQuery אין הגבלה על הגודל או על מספר העמודות בפעולות MERGE, ולכן שימוש ב-MERGE הוא אופטימיזציה שימושית. עם זאת, אם MERGE הוא בעיקר מחיקה גדולה, אפשר לעיין בהמשך המסמך כדי לראות אופטימיזציות ל-MERGE.DELETE

לסקריפטים של DML ב-BigQuery יש סמנטיקה של עקביות ששונה מעט מהצהרות מקבילות ב-Teradata. לדוגמה, יכול להיות שבטבלאות SET של Teradata במצב סשן המערכת תתעלם מכפילויות במהלך פעולת MERGE. סקירה כללית על טיפול בטבלאות MULTISET ו-SET, בידוד snapshot וטיפול בסשנים ובעסקאות מופיעה בקטע CREATE INDEX במקום אחר במסמך הזה.

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

ב-Teradata, המשתנה ACTIVITY_COUNT הוא הרחבה של Teradata ANSI SQL שאוכלסת במספר השורות שהושפעו מפקודת DML.

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

תחביר DDL

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

CREATE TABLE דוחות

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

• MULTISET. מידע נוסף מפורט בקטע CREATE INDEX.
• VOLATILE. מידע נוסף זמין בקטע טבלאות זמניות.
• [NO] FALLBACK. ראו את הקטע חזרה לגרסה קודמת.
• [NO] BEFORE JOURNAL, [NO] AFTER JOURNAL
• CHECKSUM = DEFAULT | val
• DEFAULT MERGEBLOCKRATIO
• PRIMARY INDEX (col, ...). מידע נוסף מפורט בקטע CREATE INDEX.
• UNIQUE PRIMARY INDEX. מידע נוסף מפורט בקטע CREATE INDEX.
• CONSTRAINT
• DEFAULT
• IDENTITY

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

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

המפרטים הבאים של העמודות בהצהרת CREATE TABLE לא נמצאים בשימוש ב-BigQuery:

• FORMAT 'format'. אפשר לעיין בקטע בנושא עיצוב סוגים ב-Teradata.
• ‫CHARACTER SET name. ב-BigQuery תמיד נעשה שימוש בקידוד UTF-8.
• [NOT] CASESPECIFIC
• COMPRESS val | (val, ...)

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

Teradata	BigQuery
CREATE TABLE table ( col1 VARCHAR(30) TITLE 'column desc' );	CREATE TABLE dataset.table (   col1 STRING OPTIONS(description="column desc") );

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

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

• אפשר להשתמש ב-CREATE TEMPORARY TABLE בסקריפטים, והוא תקף למשך חיי הסקריפט. אם הטבלה צריכה להתקיים מעבר לסקריפט, אפשר להשתמש באפשרויות האחרות ברשימה הזו.

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

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

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

• ‫WITH clause: אם נדרשת טבלה זמנית רק בתוך אותו בלוק, משתמשים בתוצאה זמנית באמצעות הצהרה או שאילתת משנה של WITH. זו האפשרות היעילה ביותר.

תבנית נפוצה בסקריפטים של Teradata‏ (BTEQ) היא ליצור טבלה קבועה, להוסיף לה ערך, להשתמש בה כמו בטבלה זמנית בהצהרות שוטפות, ואז למחוק או לקטוע את הטבלה. בפועל, הטבלה משמשת כמשתנה קבוע (סמפור). הגישה הזו לא יעילה ב-BigQuery, ולכן מומלץ להשתמש במקום זאת במשתנים ממשיים בScripting, או להשתמש ב-CREATE OR REPLACE עם תחביר השאילתה AS SELECT כדי ליצור טבלה שכבר יש בה ערכים.

CREATE VIEW דוחות

בטבלה הבאה מוצגים מקבילים בין Teradata לבין BigQuery עבור ההצהרה CREATE VIEW. אין צורך בסעיפים לנעילת טבלאות כמו LOCKING ROW FOR ACCESS ב-BigQuery.

הערה: ‏ Teradata לא תומכת ישירות בתצוגות חומריות כמו BigQuery, אלא רק באינדקסים של צירופים.

Teradata	BigQuery	הערות
CREATE VIEW view_name AS SELECT ...	CREATE VIEW view_name AS SELECT ...
REPLACE VIEW view_name AS SELECT ...	CREATE OR REPLACE VIEW view_name AS SELECT ...
לא נתמך	CREATE VIEW IF NOT EXISTS OPTIONS(view_option_list) AS SELECT ...	יוצר תצוגה חדשה רק אם התצוגה לא קיימת כרגע במערך הנתונים שצוין.

CREATE [UNIQUE] INDEX דוחות

ב-Teradata נדרשים אינדקסים לכל הטבלאות, ונדרשים פתרונות עקיפים מיוחדים כמו טבלאות MULTISET וטבלאות NoPI כדי לעבוד עם נתונים לא ייחודיים או לא מאונדקסים.

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

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

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

‫Teradata לא תומך בתצוגות חומריות. עם זאת, אפשר להשתמש ב-join indexes באמצעות הפקודה CREATE JOIN INDEX, שבעצם יוצרת נתונים שנדרשים לאיחוד. לא צריך אינדקסים מגובשים ב-BigQuery כדי לשפר את הביצועים, בדיוק כמו שלא צריך מקום ייעודי לאחסון זמני של נתונים לחיבורים.

במקרים אחרים של אופטימיזציה, אפשר להשתמש בתצוגות חומריות.

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

ב-Teradata, אפשר להשתמש באינדקס ייחודי כדי למנוע שורות עם מפתחות לא ייחודיים בטבלה. אם תהליך מנסה להוסיף או לעדכן נתונים עם ערך שכבר נמצא באינדקס, הפעולה תיכשל עם הפרה של האינדקס (טבלאות MULTISET) או שהמערכת תתעלם ממנה בשקט (טבלאות SET).

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

Teradata		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 (רצפים).

יצירת אינדקס כדי להשיג נעילה

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

בגלל ההבדלים האלה, לא נעשה שימוש ברכיבי Teradata הבאים ב-BigQuery:

• ON COMMIT DELETE ROWS;
• ON COMMIT PRESERVE ROWS;

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

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

CREATE PROCEDURE דוחות

הפרוצדורות המאוחסנות נתמכות כחלק מScripting ב-BigQuery.

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

Teradata	BigQuery
CREATE PROCEDURE	CREATE PROCEDURE אם נדרש שם, אחרת משתמשים ב-inline עם BEGIN או בשורה אחת עם CREATE TEMP FUNCTION.
REPLACE PROCEDURE	CREATE OR REPLACE PROCEDURE
CALL	CALL

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

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

המשתנים של BigQuery תקפים למשך משך החיים של הסקריפט.

Teradata	BigQuery
DECLARE	DECLARE
SET	SET

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

‫Teradata משתמשת ב-handlers בקודי סטטוס בהליכים לשליטה בשגיאות. ב-BigQuery, טיפול בשגיאות הוא התכונה העיקרית של זרימת הבקרה הראשית, בדומה למה ששפות אחרות מספקות עם בלוקים של TRY ... CATCH.

Teradata	BigQuery
DECLARE EXIT HANDLER FOR SQLEXCEPTION	BEGIN ... EXCEPTION WHEN ERROR THEN
SIGNAL sqlstate	RAISE message
DECLARE CONTINUE HANDLER FOR SQLSTATE VALUE 23505;	המערכת לא משתמשת ב-BigQuery ב-Exception handlers שמופעלים בתנאי שגיאה מסוימים. מומלץ להשתמש בהצהרות ASSERT במקרים שבהם משתמשים בתנאי יציאה לבדיקות מקדימות או לניפוי באגים, כי זה תואם ל-ANSI SQL:2011.

המשתנה SQLSTATE ב-Teradata דומה למשתנה המערכת @@error ב-BigQuery. ב-BigQuery, נהוג יותר לחקור שגיאות באמצעות יומני ביקורת או תצוגות INFORMATION_SCHEMA.

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

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

• DECLARE cursor_name CURSOR [FOR | WITH] ...
• PREPARE stmt_id FROM sql_str;
• OPEN cursor_name [USING var, ...];
• FETCH cursor_name INTO var, ...;
• CLOSE cursor_name;

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

התכונה Scripting ב-BigQuery תומכת בהצהרות SQL דינמיות כמו אלה שמוצגות בטבלה הבאה.

Teradata	BigQuery
EXECUTE IMMEDIATE sql_str;	EXECUTE IMMEDIATE sql_str;
EXECUTE stmt_id [USING var,...];	EXECUTE IMMEDIATE stmt_id USING var;

ההצהרות הבאות של SQL דינמי לא נמצאות בשימוש ב-BigQuery:

• PREPARE stmt_id FROM sql_str;

משפטי בקרה

התכונה Scripting ב-BigQuery תומכת בהצהרות של זרימת בקרה, כמו אלה שמוצגות בטבלה הבאה.

Teradata	BigQuery
IF condition THEN stmts ELSE stmts END IF	IF condition THEN stmts ELSE stmts END IF
label_name: LOOP stmts END LOOP label_name;	מבני בלוקים בסגנון GOTO לא נמצאים בשימוש ב-BigQuery. מומלץ לכתוב אותן מחדש כפונקציות בהגדרת המשתמש (UDF) או להשתמש בהצהרות ASSERT במקומות שבהם הן משמשות לטיפול בשגיאות.
REPEAT stmts UNTIL condition END REPEAT;	WHILE condition DO stmts END WHILE
LEAVE outer_proc_label;	הפקודה LEAVE לא משמשת לבלוקים בסגנון GOTO, אלא כמילה נרדפת ל-BREAK כדי לצאת מלולאת WHILE.
LEAVE label;	הפקודה LEAVE לא משמשת לבלוקים בסגנון GOTO, אלא כמילה נרדפת ל-BREAK כדי לצאת מלולאת WHILE.
WITH RECURSIVE temp_table AS ( ... );	ב-BigQuery לא נעשה שימוש בשאילתות רקורסיביות (שנקראות גם ביטויי טבלה נפוצים (CTE) רקורסיביים). אפשר לשכתב אותם באמצעות מערכים של UNION ALL.

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

• FOR var AS SELECT ... DO stmts END FOR;
• FOR var AS cur CURSOR FOR SELECT ... DO stmts END FOR;

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

Teradata	BigQuery
HELP TABLE table_name; HELP VIEW view_name;	SELECT  * EXCEPT(is_generated, generation_expression, is_stored, is_updatable) FROM  mydataset.INFORMATION_SCHEMA.COLUMNS; WHERE  table_name=table_name אותה שאילתה תקפה לקבלת מידע על עמודות בתצוגות. מידע נוסף זמין במאמר בנושא תצוגת העמודות ב-BigQuery INFORMATION_SCHEMA.
SELECT * FROM dbc.tables WHERE tablekind = 'T'; (Teradata DBC view)	SELECT  * EXCEPT(is_typed) FROM mydataset.INFORMATION_SCHEMA.TABLES; מידע נוסף זמין במאמר מבוא ל-BigQueryINFORMATION_SCHEMA.
HELP STATISTICS table_name;	APPROX_COUNT_DISTINCT(col)
COLLECT STATS USING SAMPLE ON table_name column (...);	לא בשימוש ב-BigQuery.
LOCKING TABLE table_name FOR EXCLUSIVE;	ב-BigQuery תמיד נעשה שימוש בבידוד snapshot. פרטים נוספים זמינים בקטע הבטחות עקביות במאמר הזה.
SET SESSION CHARACTERISTICS AS TRANSACTION ISOLATION LEVEL ...	ב-BigQuery תמיד נעשה שימוש בבידוד של תמונת מצב. פרטים נוספים זמינים בקטע הבטחות עקביות במאמר הזה.
BEGIN TRANSACTION; SELECT ... END TRANSACTION;	ב-BigQuery תמיד נעשה שימוש בבידוד של תמונת מצב. פרטים נוספים זמינים בקטע הבטחות עקביות במאמר הזה.
EXPLAIN ...	לא בשימוש ב-BigQuery. מאפיינים דומים הם הסבר על תוכנית השאילתה בממשק האינטרנט של BigQuery והקצאת משבצות שמוצגת INFORMATION_SCHEMAבתצוגות וברישום ביומן של ביקורת ב-Cloud Monitoring.
BEGIN TRANSACTION; SELECT ... END TRANSACTION;	BEGIN  BEGIN TRANSACTION;  COMMIT TRANSACTION; EXCEPTION WHEN ERROR THEN  -- Roll back the transaction inside the exception handler.  SELECT @@error.message;  ROLLBACK TRANSACTION; END;

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

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

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

קודי השגיאות של Teradata שונים מקודי השגיאות של BigQuery. BigQuery מסתמך בעיקר על קודי סטטוס של HTTP ועל הודעות שגיאה מפורטות, ומספק API בארכיטקטורת REST.

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

• ‫SQLSTATE = '02000' – 'לא נמצאה שורה'
• ‫SQLSTATE = '21000' – 'הפרה של עוצמת הקשר (אינדקס ייחודי)'
• SQLSTATE = '22000'– 'הפרת מדיניות (סוג נתונים)'
• SQLSTATE = '23000' – 'הפרת אילוץ'

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

בקטעים הבאים מוסבר איך לטפל בשגיאות ב-Scripting.

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

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

טרנזקציות

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

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

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

‫Teradata תומכת בשני מצבי ביטול שינויים בסשן: מצב ANSI בסשן ומצב Teradata בסשן (‫SET SESSION CHARACTERISTICS ו-SET SESSION TRANSACTION), בהתאם למצב הביטול שרוצים. במקרים של כשל, יכול להיות שהעסקה לא תבוטל.

‫BigQuery תומך בהצהרת ROLLBACK TRANSACTION. אין הצהרת ABORT ב-BigQuery.

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

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

הגבלה	Teradata	BigQuery
טבלאות לכל מסד נתונים	לא מוגבל	לא מוגבל
עמודות בכל טבלה	2,048	10,000
גודל שורה מקסימלי	‫1 MB	‫100 MB
אורך שם העמודה	‫128 תווים ב-Unicode	‫300 תווים ב-Unicode
אורך תיאור הטבלה	‫128 תווים ב-Unicode	‫16,384 תווי Unicode
שורות לכל טבלה	ללא הגבלה	ללא הגבלה
אורך מקסימלי של בקשת SQL	‫1 MB	‫1 MB (אורך מקסימלי של שאילתת GoogleSQL שלא נפתרה) ‫12 MB (אורך מקסימלי של שאילתת GoogleSQL ושאילתת SQL מדור קודם שנפתרה) סטרימינג: ‫10 MB (מגבלת הגודל של בקשת HTTP) ‫10,000 (מספר השורות המקסימלי לכל בקשה)
הגודל המקסימלי של בקשה ותשובה	‫7 MB (בקשה), 16 MB (תגובה)	‫10 MB (בקשה) ו-10 GB (תגובה), או כמעט ללא הגבלה אם משתמשים בעימוד או ב-Cloud Storage API.
מספר מקסימלי של סשנים בו-זמניים	‫120 לכל מנוע ניתוח (PE)	‫1,000 שאילתות בו-זמניות עם כמה הצהרות (אפשר להגדיל את המכסה באמצעות הזמנת משבצת זמן), ‫300 בקשות API בו-זמניות לכל משתמש.
מספר מקסימלי של טעינות בו-זמניות (מהירות)	‫30 (ברירת מחדל: 5)	אין הגבלה על מספר המשימות שניתן להריץ בו-זמנית, המשימות מתווספות לתור. ‫100,000 משימות טעינה לכל פרויקט ביום.