מדריך לתרגום 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	לסוגי הנתונים TIMESTAMP גם ב-Teradata וגם ב-BigQuery יש דיוק של מיקרו-שניות (אבל Teradata תומך בדקות מעוברות, ו-BigQuery לא). סוגי הנתונים של 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 שמכילות את תאריך ההתחלה ותאריך הסיום, כדי שאפשר יהיה להשתמש בהן עם פונקציות אנליטיות (window functions).
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 לפורמט DATE. או שהמפרט FORMAT X(6) בעמודה VARCHAR חותך את ערך העמודה, ולכן צריך להמיר אותו לפונקציה SUBSTR(). ההתנהגות הזו לא תואמת ל-ANSI SQL. לכן, אנחנו ממליצים לא להעביר פורמטים של עמודות ל-BigQuery.

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

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

פורמט של חותמת זמן וסוג תאריך

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

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

פורמט Teradata	תיאור של Teradata	BigQuery
CURRENT_TIMESTAMP CURRENT_TIME	מידע מסוג TIME ו-TIMESTAMP ב-Teradata יכול לכלול מידע שונה על אזור הזמן, שמוגדר באמצעות WITH TIME ZONE.	אם אפשר, כדאי להשתמש ב-CURRENT_TIMESTAMP(), שמוגדר בפורמט ISO. עם זאת, פורמט הפלט תמיד מציג את אזור הזמן 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

רוב הצהרות SELECT של Teradata תואמות ל-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. אפשר להשיג את אותה פונקציונליות באמצעות כמה אופרטורים של 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) כדי לשמור על סמנטיקה שאינה ANSI עבור NOT CASESPECIFIC, אפשר להשתמש ב- 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.
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 מונע ממשתמשים ליצור בטעות שאילתות איחוד (cross join) גדולות.
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 יכול להריץ שאילתות במקביל.

המרה והטלה של סוגים

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

Teradata	BigQuery	הערות
exp EQ exp2 exp IN (exp2, exp3)	exp = exp2 exp IN (exp2, exp3) כדי לשמור על סמנטיקה שאינה ANSI עבור NOT CASESPECIFIC, אפשר להשתמש ב- 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)	סוגי נתונים מספריים ונקודה צפה (floating point) עשויים לדרוש כללי עיגול מיוחדים כשמחילים אותם על פורמטים כמו מטבעות. (הדוגמה הזו מחזירה את הערך 48)

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

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

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

העברה של STRING אל NUMERIC או BIGNUMERIC

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

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

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

‫QUALIFY, ROWS סעיפים

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

Teradata	BigQuery
SELECT col1, col2 FROM table QUALIFY ROW_NUMBER() OVER (PARTITION BY col1 ORDER BY col2) = 1;	הסעיף QUALIFY של Teradata עם פונקציה אנליטית (window function) כמו 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 הערה: BigQuery מספק תוצאות משוערות כשמחשבים את הממוצע של ערכי INT.
BITAND	BIT_AND
BITNOT	אופרטור NOT על סיביות (~)
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

פונקציות אנליטיות ופונקציות אנליטיות (window functions)

בטבלה הבאה מופיעות פונקציות אנליטיות ופונקציות צבירה אנליטיות נפוצות של 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	אופרטור NOT על סיביות (~)
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	פונקציה מותאמת אישית בהגדרת המשתמש (UDF)
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

רוב הצהרות ה-INSERT של Teradata תואמות ל-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, לא מומלץ לעשות את זה בגלל גבול הטרנזקציה המשתמע בין ההצהרות. במקום זאת, צריך להשתמש ב-INSERT multi-value. ב-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 היא בעיקר מחיקה גדולה, עיינו באופטימיזציות של DELETE במקום אחר במסמך הזה.

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

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

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

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

תחביר DDL

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

הצהרה של CREATE TABLE

רוב ההצהרות של CREATE TABLE ב-Teradata תואמות ל-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 יש תמיכה בטבלאות volatile, שמשמשות בדרך כלל לאחסון תוצאות ביניים בסקריפטים. יש כמה דרכים להשיג תוצאה דומה לטבלאות זמניות ב-BigQuery:

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

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

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

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

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

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

הצהרה של CREATE VIEW

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

הערה: ב-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 אין תמיכה בתצוגות מהותיות. עם זאת, הוא מציע אינדקסים של איחוד באמצעות ההצהרה CREATE JOIN INDEX, שבעצם יוצרת את הנתונים שנדרשים לאיחוד. ב-BigQuery לא צריך אינדקסים מנוהלים כדי לשפר את הביצועים, כמו שלא צריך שטח ייעודי ל-spool בשביל פעולות join.

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

הוספה לאינדקס לצורך עקביות (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 מספקת משאבים ב-access module processor (AMP). שאילתות יכולות לצרוך משאבים של כל ה-AMP, של AMP יחיד או של קבוצת AMP. הצהרות DDL הן מסוג all-AMP, ולכן הן דומות לנעילת DDL גלובלית. ב-BigQuery אין מנגנון נעילה כזה, ואפשר להריץ בו שאילתות ופקודות INSERT בו-זמנית עד למכסה. רק לפקודות DML מסוג UPDATE שפועלות בו-זמנית יש השלכות מסוימות על בו-זמניות: פעולות UPDATE באותו מחיצה נכנסות לתור כדי להבטיח בידוד snapshot, כך שלא צריך לנעול כדי למנוע קריאות פנטום או עדכונים שאבדו.

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

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

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

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

הצהרה של CREATE PROCEDURE

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

תכונת הסקריפטים ב-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;

הצהרות של בקרת זרימה

התכונה "כתיבת סקריפטים" ב-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;	ב-BigQuery לא משתמשים במבני בלוקים בסגנון GOTO. מומלץ לשכתב אותם כפונקציות בהגדרת המשתמש (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 ( ... );	שאילתות רקורסיביות (שנקראות גם ביטויי טבלה נפוצים (CTE) רקורסיביים) לא נמצאות בשימוש ב-BigQuery. אפשר לשכתב אותם באמצעות מערכים של 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)	SELECT  * EXCEPT(is_typed) FROM mydataset.INFORMATION_SCHEMA.TABLES; למידע נוסף, קראו את המבוא ל-BigQuery INFORMATION_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 תמיד נעשה שימוש בבידוד snapshot. למידע נוסף, ראו הבטחות לעקביות במקום אחר במסמך הזה.
BEGIN TRANSACTION; SELECT ... END TRANSACTION;	ב-BigQuery תמיד נעשה שימוש בבידוד snapshot. למידע נוסף, ראו הבטחות לעקביות במקום אחר במסמך הזה.
EXPLAIN ...	לא בשימוש ב-BigQuery. מאפיינים דומים הם הסבר על תוכנית לביצוע שאילתה בממשק האינטרנט של BigQuery והקצאת ה-slots שמוצגת בתצוגות 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 עם מספר הצהרות ומספר שורות

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

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

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

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

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

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

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

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

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

טרנזקציות

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

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