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

מערכת אחסון הנתונים של IBM Netezza מיועדת לעבודה עם תחביר SQL ספציפי ל-Netezza. ‫Netezza SQL מבוסס על Postgres 7.2. אי אפשר להשתמש בסקריפטים של SQL שנכתבו עבור Netezza במחסן נתונים של BigQuery בלי לבצע שינויים, כי יש הבדלים בין דיאלקטי ה-SQL.

במסמך הזה מפורטים קווי הדמיון וההבדלים בתחביר SQL בין Netezza לבין BigQuery בתחומים הבאים:

סוגי נתונים
רכיבי שפת SQL
תחביר של שאילתות
שפת טיפול בנתונים (DML)
שפת הגדרת נתונים (DDL)
תהליכים מאוחסנים
פונקציות

אפשר גם להשתמש בתרגום SQL באצווה כדי להעביר את סקריפטים של SQL בכמות גדולה, או בתרגום SQL אינטראקטיבי כדי לתרגם שאילתות אד-הוק. שני הכלים תומכים ב-IBM Netezza SQL/NZPLSQL בגרסת תצוגה מקדימה.

סוגי נתונים

Netezza	BigQuery	Notes
`INTEGER/INT/INT4`	`INT64`
`SMALLINT/INT2`	`INT64`
`BYTEINT/INT1`	`INT64`
`BIGINT/INT8`	`INT64`
`DECIMAL`	`NUMERIC`	סוג הנתונים `DECIMAL` ב-Netezza הוא כינוי לסוג הנתונים `NUMERIC`.
`NUMERIC`]	`NUMERIC` `INT64`
`NUMERIC(p,s)`	`NUMERIC`	סוג הנתונים `NUMERIC` ב-BigQuery לא מגביל את מספר הספרות או את קנה המידה (אילוצים) כמו ב-Netezza. ב-BigQuery יש 9 ספרות קבועות אחרי הנקודה העשרונית, ואילו ב-Netezza אפשר להגדיר את זה באופן מותאם אישית. ב-Netezza, הדיוק `p` יכול להיות בין 1 ל-38, והקנה מידה `s` יכול להיות בין 0 לדיוק.
`FLOAT(p)`	`FLOAT64`
`REAL/FLOAT(6)`	`FLOAT64`
`DOUBLE PRECISION/FLOAT(14)`	`FLOAT64`
`CHAR/CHARACTER`	`STRING`	הסוג `STRING` ב-BigQuery הוא באורך משתנה, ולא צריך להגדיר ידנית אורך מקסימלי של תווים כמו בסוגים `CHARACTER` ו-`VARCHAR` ב-Netezza. ערך ברירת המחדל של `n` ב-`CHAR(n)` הוא 1. הגודל המקסימלי של מחרוזת התווים הוא 64,000.
`VARCHAR`	`STRING`	הסוג `STRING` ב-BigQuery הוא באורך משתנה, ולא צריך להגדיר ידנית אורך מקסימלי של תווים כמו בסוגים `CHARACTER` ו-`VARCHAR` ב-Netezza. הגודל המקסימלי של מחרוזת התווים הוא 64,000.
`NCHAR`	`STRING`	הסוג `STRING` ב-BigQuery מאוחסן כ-Unicode בקידוד UTF-8 באורך משתנה. האורך המקסימלי הוא 16,000 תווים.
`NVARCHAR`	`STRING`	הסוג `STRING` ב-BigQuery מאוחסן כ-Unicode עם קידוד UTF-8 באורך משתנה. האורך המקסימלי הוא 16,000 תווים.
`VARBINARY`	`BYTES`
`ST_GEOMETRY`	`GEOGRAPHY`
`BOOLEAN/BOOL`	`BOOL`	הסוג `BOOL` ב-BigQuery יכול לקבל רק `TRUE/FALSE`, בניגוד לסוג `BOOL` ב-Netezza, שיכול לקבל מגוון ערכים כמו `0/1`,‏ `yes/no`, ‏ `true/false,`‏ `on/off`.
`DATE`	`DATE`
`TIME`	`TIME`
`TIMETZ/TIME WITH TIME ZONE`	`TIME`	ב-Netezza, סוג הנתונים `TIME` מאוחסן בזמן UTC, ואפשר להעביר סטייה משעון UTC באמצעות התחביר `WITH TIME ZONE`. סוג הנתונים `TIME` ב-BigQuery מייצג שעה שלא תלויה בתאריך או באזור זמן.
`TIMESTAMP`	`DATETIME`	הסוג Netezza `TIMESTAMP` לא כולל אזור זמן, כמו הסוג `DATETIME` BigQuery.
	`ARRAY`	אין סוג נתונים של מערך ב-Netezza. במקום זאת, סוג המערך מאוחסן בשדה varchar.

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

כשממירים רכיבי עיצוב של סוג התאריך מ-Netezza ל-GoogleSQL, צריך לשים לב במיוחד להבדלים באזורי הזמן בין TIMESTAMP לבין DATETIME, כפי שמסוכם בטבלה הבאה:

Netezza	BigQuery
`CURRENT_TIMESTAMP` `CURRENT_TIME` ב-Netezza, למידע `TIME` יכול להיות מידע שונה על אזור זמן, שמוגדר באמצעות התחביר `WITH TIME ZONE`.	אם אפשר, כדאי להשתמש בפונקציה `CURRENT_TIMESTAMP`, שהפורמט שלה נכון. עם זאת, פורמט הפלט לא תמיד מציג את אזור הזמן UTC (באופן פנימי, ב-BigQuery אין אזור זמן). האובייקט `DATETIME` בכלי שורת הפקודה של BigQuery ובמסוףGoogle Cloud מפורמט באמצעות מפריד `T` בהתאם ל-RFC 3339. עם זאת, ב-Python וב-Java JDBC, משתמשים ברווח כמפריד. כדי להגדיר את פורמט התאריך בצורה נכונה, צריך להשתמש בפונקציה המפורשת `FORMAT_DATETIME`. אחרת, מתבצעת המרה מפורשת למחרוזת, לדוגמה: `CAST(CURRENT_DATETIME() AS STRING)` גם כאן מוחזר מפריד של רווח.
`CURRENT_DATE`	`CURRENT_DATE`
`CURRENT_DATE-3`	‫BigQuery לא תומך בפעולות אריתמטיות על נתונים. במקום זאת, צריך להשתמש בפונקציה `DATE_ADD`.

`SELECT` דוחות

באופן כללי, ההצהרה SELECT של Netezza תואמת ל-BigQuery. בטבלה הבאה מפורטים המקרים החריגים:

Netezza BigQuery

Netezza	BigQuery
הצהרת `SELECT` ללא סעיף `FROM`	תומך במקרים מיוחדים כמו: `SELECT 1 UNION ALL SELECT 2;`
SELECT (subquery) AS flag, CASE WHEN flag = 1 THEN ...	ב-BigQuery, עמודות לא יכולות להפנות לפלט של עמודות אחרות שמוגדרות באותה שאילתה. צריך לשכפל את הלוגיקה או להעביר אותה לשאילתה מקוננת. אפשרות 1 SELECT (subquery) AS flag, CASE WHEN (subquery) = 1 THEN ... אפשרות 2 SELECT q.*, CASE WHEN flag = 1 THEN ... FROM ( SELECT (subquery) AS flag, ... ) AS q

הצהרת SELECT ללא סעיף FROM

תומך במקרים מיוחדים כמו:

SELECT 1 UNION ALL SELECT 2;

SELECT
  (subquery) AS flag,
  CASE WHEN flag = 1 THEN ...

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

אפשרות 1

SELECT
  (subquery) AS flag,
  CASE WHEN (subquery) = 1 THEN ...

אפשרות 2

SELECT
  q.*,
  CASE WHEN flag = 1 THEN ...
FROM (
  SELECT
    (subquery) AS flag,
    ...
  ) AS q

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

Netezza	BigQuery	תיאור
`exp = exp2`	`exp = exp2`	שווה
`exp <= exp2`	`exp <= exp2`	פחות מ- או שווה ל-
`exp < exp2`	`exp < exp2`	פחות מ-
`exp <> exp2` `exp != exp2`	`exp <> exp2` `exp != exp2`	לא שווה
`exp >= exp2`	`exp >= exp2`	גדול מ- או שווה ל-
`exp > exp2`	`exp > exp2`	גדול מ-

פונקציות SQL מובנות

Netezza	BigQuery	תיאור
`CURRENT_DATE`	`CURRENT_DATE`	קבלת התאריך הנוכחי (שנה, חודש ויום).
`CURRENT_TIME`	`CURRENT_TIME`	קבלת השעה הנוכחית עם שבריר.
`CURRENT_TIMESTAMP`	`CURRENT_TIMESTAMP`	לקבל את התאריך והשעה הנוכחיים במערכת, עד לשנייה המלאה הקרובה.
`NOW`	`CURRENT_TIMESTAMP`	הפונקציה מחזירה את התאריך והשעה הנוכחיים של המערכת, עד לשנייה המלאה הקרובה.
`COALESCE(exp, 0)`	`COALESCE(exp, 0)`	מחליפים את `NULL` באפס.
`NVL(exp, 0)`	`IFNULL(exp, 0)`	מחליפים את `NULL` באפס.
`EXTRACT(DOY FROM timestamp_expression)`	`EXTRACT(DAYOFYEAR FROM timestamp_expression)`	הפונקציה מחזירה את מספר הימים מתחילת השנה.
`ADD_MONTHS(date_expr, num_expr)`	`DATE_ADD(date, INTERVAL k MONTH)`	הוספת חודשים לתאריך.
`DURATION_ADD(date, k)`	`DATE_ADD(date, INTERVAL k DAY)`	ביצוע פעולת חיבור על תאריכים.
`DURATION_SUBTRACT(date, k)`	`DATE_SUB(date, INTERVAL k DAY)`	ביצוע פעולת חיסור על תאריכים.
`str1 \|\| str2`	`CONCAT(str1, str2)`	שרשור מחרוזות.

פונקציות

בקטע הזה מוצגת השוואה בין פונקציות של Netezza ושל BigQuery.

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

Netezza	BigQuery
	`ANY_VALUE`
	`APPROX_COUNT_DISTINCT`
	`APPROX_QUANTILES`
	`APPROX_TOP_COUNT`
	`APPROX_TOP_SUM`
`AVG`	`AVG`
`intNand`	`BIT_AND`
`intNnot`	אופרטור השלילה ברמת הביטים: `~`
`intNor`	`BIT_OR`
`intNxor`	`BIT_XOR`
`intNshl`
`intNshr`
`CORR`	`CORR`
`COUNT`	`COUNT`
	`COUNTIF`
`COVAR_POP`	`COVAR_POP`
`COVAR_SAMP`	`COVAR_SAMP`
`GROUPING`
	`LOGICAL_AND`
	`LOGICAL_OR`
`MAX`	`MAX`
`MIN`	`MIN`
`MEDIAN`	`PERCENTILE_CONT(x, 0.5)`
`STDDEV_POP`	`STDDEV_POP`
`STDDEV_SAMP`	`STDDEV_SAMP` `STDDEV`
	`STRING_AGG`
`SUM`	`SUM`
`VAR_POP`	`VAR_POP`
`VAR_SAMP`	`VAR_SAMP` `VARIANCE`

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

Netezza	BigQuery
	`ANY_VALUE`
	`ARRAY_AGG`
`ARRAY_CONCAT`	`ARRAY_CONCAT_AGG`
`ARRAY_COMBINE`
`ARRAY_COUNT`
`ARRAY_SPLIT`
`ARRAY_TYPE`
`AVG`	`AVG`
`intNand`	`BIT_AND`
`intNnot`	אופרטור השלילה ברמת הביטים: `~`
`intNor`	`BIT_OR`
`intNxor`	`BIT_XOR`
`intNshl`
`intNshr`
`CORR`	`CORR`
`COUNT`	`COUNT`
	`COUNTIF`
`COVAR_POP`	`COVAR_POP`
`COVAR_SAMP`	`COVAR_SAMP`
`CUME_DIST`	`CUME_DIST`
`DENSE_RANK`	`DENSE_RANK`
`FIRST_VALUE`	`FIRST_VALUE`
`LAG`	`LAG`
`LAST_VALUE`	`LAST_VALUE`
`LEAD`	`LEAD`
`AND`	`LOGICAL_AND`
`OR`	`LOGICAL_OR`
`MAX`	`MAX`
`MIN`	`MIN`
	`NTH_VALUE`
`NTILE`	`NTILE`
`PERCENT_RANK`	`PERCENT_RANK`
`PERCENTILE_CONT`	`PERCENTILE_CONT`
`PERCENTILE_DISC`	`PERCENTILE_DISC`
`RANK`	`RANK`
`ROW_NUMBER`	`ROW_NUMBER`
`STDDEV`	`STDDEV`
`STDDEV_POP`	`STDDEV_POP`
`STDDEV_SAMP`	`STDDEV_SAMP`
	`STRING_AGG`
`SUM`	`SUM`
`VARIANCE`	`VARIANCE`
`VAR_POP`	`VAR_POP`
`VAR_SAMP`	`VAR_SAMP` `VARIANCE`
`WIDTH_BUCKET`

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

Netezza	BigQuery
`ADD_MONTHS`	`DATE_ADD` `TIMESTAMP_ADD`
`AGE`
`CURRENT_DATE`	`CURRENT_DATE`
	`CURRENT_DATETIME`
`CURRENT_TIME`	`CURRENT_TIME`
`CURRENT_TIME(p)`
`CURRENT_TIMESTAMP`	`CURRENT_TIMESTAMP`
`CURRENT_TIMESTAMP(p)`
	`DATE`
	`DATE_ADD`
	`DATE_DIFF`
	`DATE_FROM_UNIX_DATE`
	`DATE_SUB`
`DATE_TRUNC`	`DATE_TRUNC`
`DATE_PART`
	`DATETIME`
	`DATETIME_ADD`
	`DATETIME_DIFF`
	`DATETIME_SUB`
	`DATETIME_TRUNC`
`DURATION_ADD`
`DURATION_SUBTRACT`
`EXTRACT`	`EXTRACT (DATE)` `EXTRACT (TIMESTAMP)`
	`FORMAT_DATE`
	`FORMAT_DATETIME`
	`FORMAT_TIME`
	`FORMAT_TIMESTAMP`
`LAST_DAY`	`DATE_SUB(` `DATE_TRUNC(` `DATE_ADD(` `date_expression, INTERVAL 1 MONTH ), MONTH ),` `INTERVAL 1 DAY )`
`MONTHS_BETWEEN`	`DATE_DIFF(date_expression,` `date_expression, MONTH)`
`NEXT_DAY`
`NOW`
`OVERLAPS`
	`PARSE_DATE`
	`PARSE_DATETIME`
	`PARSE_TIME`
	`PARSE_TIMESTAMP`
	`STRING`
	`TIME`
	`TIME_ADD`
	`TIME_DIFF`
	`TIME_SUB`
	`TIME_TRUNC`
`TIMEOFDAY`
`TIMESTAMP`	`DATETIME`
	`TIMESTAMP_ADD`
	`TIMESTAMP_DIFF`
	`TIMESTAMP_MICROS`
	`TIMESTAMP_MILLIS`
	`TIMESTAMP_SECONDS`
	`TIMESTAMP_SUB`
	`TIMESTAMP_TRUNC`
`TIMEZONE`
`TO_DATE`	`PARSE_DATE`
`TO_TIMESTAMP`	`PARSE_TIMESTAMP`
	`UNIX_DATE`
	`UNIX_MICROS`
	`UNIX_MILLIS`
	`UNIX_SECONDS`

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

Netezza	BigQuery
`ASCII`	`TO_CODE_POINTS(string_expr)[OFFSET(0)]`
	`BYTE_LENGTH`
	`TO_HEX`
	`CHAR_LENGTH`
	`CHARACTER_LENGTH`
	`CODE_POINTS_TO_BYTES`
`BTRIM`
`CHR`	`CODE_POINTS_TO_STRING([numeric_expr])`
	`CONCAT`
`DBL_MP`
`DLE_DST`
	`ENDS_WITH`
	`FORMAT`
	`FROM_BASE32`
	`FROM_BASE64`
	`FROM_HEX`
`HEX_TO_BINARY`
`HEX_TO_GEOMETRY`
`INITCAP`
`INSTR`
`INT_TO_STRING`
`LE_DST`
`LENGTH`	`LENGTH`
`LOWER`	`LOWER`
`LPAD`	`LPAD`
`LTRIM`	`LTRIM`
	`NORMALIZE`
	`NORMALIZE_AND_CASEFOLD`
`PRI_MP`
	`REGEXP_CONTAINS`
`REGEXP_EXTRACT`	`REGEXP_EXTRACT`
`REGEXP_EXTRACT_ALL`	`REGEXP_EXTRACT_ALL`
`REGEXP_EXTRACT_ALL_SP`
`REGEXP_EXTRACT_SP`
`REGEXP_INSTR`	`STRPOS(col,` `REGEXP_EXTRACT()`)
`REGEXP_LIKE`
`REGEXP_MATCH_COUNT`
`REGEXP_REPLACE`	`REGEXP_REPLACE`
`REGEXP_REPLACE_SP`	`IF(REGEXP_CONTAINS,1,0)`
	`REGEXP_EXTRACT`
`REPEAT`	`REPEAT`
	`REPLACE`
	`REVERSE`
`RPAD`	`RPAD`
`RTRIM`	`RTRIM`
	`SAFE_CONVERT_BYTES_TO_STRING`
`SCORE_MP`
`SEC_MP`
`SOUNDEX`
	`SPLIT`
	`STARTS_WITH`
`STRING_TO_INT`
`STRPOS`	`STRPOS`
`SUBSTR`	`SUBSTR`
	`TO_BASE32`
	`TO_BASE64`
`TO_CHAR`
`TO_DATE`
`TO_NUMBER`
`TO_TIMESTAMP`
	`TO_CODE_POINTS`
	`TO_HEX`
`TRANSLATE`
	`TRIM`
`UPPER`	`UPPER`
`UNICODE`
`UNICODES`

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

Netezza	BigQuery
`ABS`	`ABS`
`ACOS`	`ACOS`
	`ACOSH`
`ASIN`	`ASIN`
	`ASINH`
`ATAN`	`ATAN`
`ATAN2`	`ATAN2`
	`ATANH`
`CEIL` `DCEIL`	`CEIL`
	`CEILING`
`COS`	`COS`
	`COSH`
`COT`	`COT`
`DEGREES`
	`DIV`
`EXP`	`EXP`
`FLOOR` `DFLOOR`	`FLOOR`
`GREATEST`	`GREATEST`
	`IEEE_DIVIDE`
	`IS_INF`
	`IS_NAN`
`LEAST`	`LEAST`
`LN`	`LN`
`LOG`	`LOG`
	`LOG10`
`MOD`	`MOD`
	`NULLIF(expr, 0)`
`PI`	`ACOS(-1)`
`POW` `FPOW`	`POWER` `POW`
`RADIANS`
`RANDOM`	`RAND`
`ROUND`	`ROUND`
	`SAFE_DIVIDE`
`SETSEED`
`SIGN`	`SIGN`
`SIN`	`SIN`
	`SINH`
`SQRT` `NUMERIC_SQRT`	`SQRT`
`TAN`	`TAN`
	`TANH`
`TRUNC`	`TRUNC`
	`IFNULL(expr, 0)`

תחביר DML

בקטע הזה מוצגת השוואה בין התחביר של Netezza ושל BigQuery DML.

`INSERT` דוחות

Netezza BigQuery

Netezza	BigQuery
INSERT INTO table VALUES (...);	INSERT INTO table (...) VALUES (...); ב-Netezza יש מילת מפתח `DEFAULT` ואילוצים אחרים לעמודות. ב-BigQuery, השמטת שמות של עמודות בהצהרת `INSERT` תקפה רק אם כל העמודות מצוינות.
INSERT INTO table (...) VALUES (...); INSERT INTO table (...) VALUES (...);	INSERT INTO table VALUES (), (); ב-BigQuery יש מכסות DML שמגבילות את מספר הצהרות ה-DML שאפשר להריץ מדי יום. כדי להפיק את המרב מהמכסה, כדאי לנסות את הגישות הבאות: לשלב כמה שורות בהצהרת `INSERT` אחת, במקום שורה אחת לכל הצהרת `INSERT`. לשלב כמה פקודות DML (כולל פקודת `INSERT`) באמצעות פקודת `MERGE`. משתמשים בהצהרת `CREATE TABLE ... AS SELECT` כדי ליצור טבלאות חדשות ולאכלס אותן.

INSERT INTO table VALUES (...);

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

ב-Netezza יש מילת מפתח DEFAULT ואילוצים אחרים לעמודות. ב-BigQuery, השמטת שמות של עמודות בהצהרת INSERT תקפה רק אם כל העמודות מצוינות.

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

INSERT INTO table VALUES (), ();

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

לשלב כמה שורות בהצהרת INSERT אחת, במקום שורה אחת לכל הצהרת INSERT.

לשלב כמה פקודות DML (כולל פקודת INSERT) באמצעות פקודת MERGE.

משתמשים בהצהרת CREATE TABLE ... AS SELECT כדי ליצור טבלאות חדשות ולאכלס אותן.

לסקריפטים של DML ב-BigQuery יש סמנטיקה של עקביות ששונה מעט מההצהרות המקבילות ב-Netezza. חשוב גם לדעת שב-BigQuery אין אילוצים מלבד NOT NULL.

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

`UPDATE` דוחות

ב-Netezza, סעיף WHERE הוא אופציונלי, אבל ב-BigQuery הוא נדרש.

Netezza BigQuery

Netezza	BigQuery
UPDATE tbl SET tbl.col1=val1;	האפשרות הזו לא נתמכת בלי הסעיף `WHERE`. כדי לעדכן את כל השורות, משתמשים בסעיף `WHERE true`.
UPDATE A SET y = B.y, z = B.z + 1 FROM B WHERE A.x = B.x AND A.y IS NULL;	UPDATE A SET y = B.y, z = B.z + 1 FROM B WHERE A.x = B.x AND A.y IS NULL;
UPDATE A alias SET x = x + 1 WHERE f(x) IN (0, 1)	UPDATE A SET x = x + 1 WHERE f(x) IN (0, 1);
UPDATE A SET z = B.z FROM B WHERE A.x = B.x AND A.y = B.y	UPDATE A SET z = B.z FROM B WHERE A.x = B.x AND A.y = B.y;

UPDATE tbl
SET
tbl.col1=val1;

האפשרות הזו לא נתמכת בלי הסעיף WHERE. כדי לעדכן את כל השורות, משתמשים בסעיף WHERE true.

UPDATE A
SET
  y = B.y,
  z = B.z + 1
FROM B
WHERE A.x = B.x
  AND A.y IS NULL;

UPDATE A
SET
  y = B.y,
  z = B.z + 1
FROM B
WHERE A.x = B.x
  AND A.y IS NULL;

UPDATE A alias
SET x = x + 1
WHERE f(x) IN (0, 1)

UPDATE A
SET x = x + 1
WHERE f(x) IN (0, 1);

UPDATE A
SET z = B.z
FROM B
WHERE A.x = B.x
  AND A.y = B.y

UPDATE A
SET z = B.z
FROM B
WHERE A.x = B.x
  AND A.y = B.y;

לדוגמאות, אפשר לעיין בדוגמאות של UPDATE.

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

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

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

ב-BigQuery, להצהרת DELETE חייב להיות סעיף WHERE. ב-Netezza, סעיף WHERE הוא אופציונלי. אם לא מציינים את סעיף WHERE, כל השורות בטבלת Netezza נמחקות.

Netezza BigQuery תיאור

Netezza	BigQuery	תיאור
BEGIN; LOCK TABLE A IN EXCLUSIVE MODE; DELETE FROM A; INSERT INTO A SELECT * FROM B; COMMIT;	החלפת התוכן של טבלה בפלט של שאילתה שווה לעסקה. אפשר לעשות את זה באמצעות פעולת `query` או פעולת העתקה (`cp`). bq query \ --replace \ --destination_table \ tableA \ 'SELECT * \ FROM tableB \ WHERE ...' bq cp \ -f tableA tableB	החלפת התוכן של טבלה בתוצאות של שאילתה.
DELETE FROM database.table	DELETE FROM table WHERE TRUE;	ב-Netezza, כשמריצים הצהרת מחיקה, השורות לא נמחקות פיזית אלא רק מסומנות למחיקה. הפעלת הפקודות `GROOM TABLE` או `nzreclaim` מאוחר יותר מסירה את השורות שמסומנות למחיקה ומפנה את שטח הדיסק התואם.
`GROOM TABLE`		ב-Netezza משתמשים בפקודה `GROOM TABLE` כדי לפנות מקום בדיסק על ידי הסרת שורות שמסומנות למחיקה.

BEGIN;
LOCK TABLE A IN EXCLUSIVE MODE;
DELETE FROM A;
INSERT INTO A SELECT * FROM B;
COMMIT;

החלפת התוכן של טבלה בפלט של שאילתה שווה לעסקה. אפשר לעשות את זה באמצעות פעולת query או פעולת העתקה (cp).

bq query \

--replace \

--destination_table \

tableA \

'SELECT * \

FROM tableB \

WHERE ...'

bq cp \

-f tableA tableB

החלפת התוכן של טבלה בתוצאות של שאילתה.

DELETE FROM database.table

DELETE FROM table WHERE TRUE;

ב-Netezza, כשמריצים הצהרת מחיקה, השורות לא נמחקות פיזית אלא רק מסומנות למחיקה. הפעלת הפקודות GROOM TABLE או nzreclaim מאוחר יותר מסירה את השורות שמסומנות למחיקה ומפנה את שטח הדיסק התואם.

GROOM TABLE ב-Netezza משתמשים בפקודה GROOM TABLE כדי לפנות מקום בדיסק על ידי הסרת שורות שמסומנות למחיקה.

`MERGE` דוחות

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

תחביר DDL

בקטע הזה מוצגת השוואה בין תחביר DDL של Netezza לבין תחביר DDL של BigQuery.

`CREATE TABLE` דוחות

Netezza	BigQuery	תיאור
`TEMP` `TEMPORARY`	בעזרת התמיכה של BigQuery ב-DDL, אתם יכולים ליצור טבלה מתוצאות של שאילתה ולהגדיר את תאריך התפוגה שלה בזמן היצירה. לדוגמה, ל-3 ימים: `CREATE TABLE` `'my-project.public_dump.vtemp'` `OPTIONS`( `expiration_timestamp=TIMESTAMP_ADD(CURRENT_TIMESTAMP(),` `INTERVAL 3 DAY))`	ליצור טבלאות זמניות לסשן.
`ZONE MAPS`	לא נתמך.	חיפוש מהיר של תנאי `WHERE`.
`DISTRIBUTE ON`	`PARTITION BY`	חלוקה למחיצות. זה לא תרגום ישיר. ‫`DISTRIBUTE ON` משתף נתונים בין צמתים, בדרך כלל עם מפתח ייחודי לחלוקה שווה, ואילו `PARTITION BY` מצמצם נתונים לפלחים.
`ORGANIZE ON`	`CLUSTER BY`	גם Netezza וגם BigQuery תומכים בעד ארבעה מפתחות לאשכולות. טבלאות בסיס מקובצות (CBT) של Netezza מספקות עדיפות שווה לכל העמודות של האשכול. ב-BigQuery, העדיפות ניתנת לעמודה הראשונה שלפיה הטבלה מקובצת, ואחריה לעמודה השנייה וכן הלאה.
`ROW SECURITY`	`Authorized View`	אבטחה ברמת השורה.
`CONSTRAINT`	לא נתמך	בודקים את האילוצים.

`DROP` דוחות

Netezza	BigQuery	תיאור
`DROP TABLE`	`DROP TABLE`
`DROP DATABASE`	`DROP DATABASE`
`DROP VIEW`	`DROP VIEW`

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

Netezza	BigQuery	תיאור
`NULL` `NOT NULL`	`NULLABLE` `REQUIRED`	מציינים אם העמודה יכולה להכיל ערכים של `NULL`.
`REFERENCES`	לא נתמך	מציינים אילוצים לעמודה.
`UNIQUE`	לא נתמך	כל ערך בעמודה חייב להיות ייחודי.
`DEFAULT`	לא נתמך	ערך ברירת המחדל לכל הערכים בעמודה.

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

‫Netezza תומך בטבלאות TEMPORARY שקיימות למשך הסשן.

כדי ליצור טבלה זמנית ב-BigQuery:

יוצרים מערך נתונים עם אורך חיים קצר (למשל, 12 שעות).
יוצרים את הטבלה הזמנית במערך הנתונים, עם קידומת לשם הטבלה temp. לדוגמה, כדי ליצור טבלה שתפוג תוך שעה, מבצעים את הפעולות הבאות:
```
CREATE TABLE temp.name (col1, col2, ...)
OPTIONS(expiration_timestamp = TIMESTAMP_ADD(CURRENT_TIMESTAMP(),
INTERVAL 1 HOUR));
```
מתחילים לקרוא ולכתוב מהטבלה הזמנית.

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

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

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

ב-Netezza משתמשים בשפת הסקריפטים NZPLSQL כדי לעבוד עם נהלים מאוחסנים. ‫NZPLSQL מבוססת על השפה PL/pgSQL של Postgres. בקטע הזה מוסבר איך להמיר הצהרות SQL פרוצדורליות שמשמשות בפרוצדורות מאוחסנות, בפונקציות ובטריגרים מ-Netezza ל-BigQuery.

`CREATE PROCEDURE` דוחות

גם Netezza וגם BigQuery תומכים ביצירת תהליכים מאוחסנים באמצעות ההצהרה CREATE PROCEDURE. מידע נוסף מופיע במאמר בנושא עבודה עם פרוצדורות מאוחסנות של SQL.

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

Netezza	BigQuery	תיאור
`DECLARE var datatype(len) [DEFAULT value];`	`DECLARE`	הצהרה על משתנה.
`SET var = value;`	`SET`	הקצאת ערך למשתנה.

‫Exception handlers

‫Netezza תומכת בטיפול בחריגים שאפשר להפעיל במקרים מסוימים של שגיאות. ‫BigQuery לא תומך ב-condition handlers.

Netezza	BigQuery	תיאור
`EXCEPTION`	לא נתמך	הצהרה על רכיב handler של חריגות SQL לשגיאות כלליות.

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

‫Netezza תומך בשאילתות SQL דינמיות בתוך פרוצדורות מאוחסנות. ‫BigQuery לא תומך בהצהרות SQL דינמיות.

Netezza	BigQuery	תיאור
`EXECUTE IMMEDIATE` `sql_str;`	`EXECUTE IMMEDIATE` `sql_str;`	הפעלת SQL דינמי.

משפטי בקרה

Netezza	BigQuery	תיאור
`IF THEN ELSE STATEMENT` `IF` condition `THEN ...` `ELSE ...` `END IF;`	`IF` condition `THEN ...` `ELSE ...` `END IF;`	הפעלה בתנאי.
Iterative Control `FOR var AS SELECT ...` `DO` stmts `END FOR;` `FOR var AS cur CURSOR` `FOR SELECT ...` `DO stmts END FOR;`	לא נתמך	חזרה על פעולה מסוימת על אוסף של שורות.
Iterative Control `LOOP stmts END LOOP;`	`LOOP` `sql_statement_list END LOOP;`	חסימת לולאה של הצהרות.
`EXIT WHEN`	`BREAK`	יציאה מההליך.
`WHILE condition LOOP`	`WHILE` condition `DO ...` `END WHILE`	מבצעים לולאה של הצהרות עד שתנאי while נכשל.

הצהרות אחרות ורכיבי שפה פרוצדורליים

Netezza	BigQuery	תיאור
`CALL` `proc(param,...)`	לא נתמך	מפעילים פרוצדורה.
`EXEC` `proc(param,...)`	לא נתמך	מפעילים פרוצדורה.
`EXECUTE` `proc(param,...)`	לא נתמך	מפעילים פרוצדורה.

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

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

הצהרות SQL אחרות

Netezza	BigQuery	תיאור
`GENERATE STATISTICS`		תייצר נתונים סטטיסטיים לכל הטבלאות במסד הנתונים הנוכחי.
`GENERATE STATISTICS ON table_name`		יצירת נתונים סטטיסטיים לטבלה ספציפית.
`GENERATE STATISTICS ON table_name(col1,col4)`	אפשר להשתמש בפונקציות סטטיסטיות כמו `MIN, MAX, AVG,` וכו', בממשק המשתמש או ב-Cloud Data Loss Prevention API.	יצירת נתונים סטטיסטיים לעמודות ספציפיות בטבלה.
`GENERATE STATISTICS ON table_name`	`APPROX_COUNT_DISTINCT(col)`	הצגת מספר הערכים הייחודיים בעמודות.
`INSERT INTO table_name`	`INSERT INTO table_name`	מוסיפים שורה.
`LOCK TABLE` `table_name FOR` `EXCLUSIVE;`	לא נתמך	נעילת השורה.
`SET SESSION` `CHARACTERISTICS AS` `TRANSACTION ISOLATION LEVEL` ...	ב-BigQuery תמיד נעשה שימוש בבידוד של תמונת מצב. פרטים נוספים זמינים במאמר בנושא עקביות והפרדה של טרנזקציות.	מגדירים את רמת הבידוד של העסקה.
`BEGIN TRANSACTION` `END TRANSACTION` `COMMIT`	ב-BigQuery תמיד נעשה שימוש בבידוד של תמונת מצב. פרטים נוספים זמינים במאמר בנושא עקביות והפרדה של טרנזקציות.	הגדרת גבולות העסקה לבקשות עם כמה הצהרות.
`EXPLAIN` ...	לא נתמך. תכונות דומות בתוכנית השאילתה ובציר הזמן	הצגת תוכנית שאילתה עבור הצהרת `SELECT`.
משתמשים יכולים לראות מטא-נתונים מטא-נתונים של המערכת	`SELECT` `* EXCEPT(is_typed)` `FROM` `mydataset.INFORMATION_SCHEMA.TABLES;` BigQuery Information Schema	שאילתת אובייקטים במסד הנתונים

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

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

טרנזקציות

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

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

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

‫Netezza תומך בהצהרת ROLLBACK TRANSACTION כדי לבטל את העסקה הנוכחית ולבטל את כל השינויים שבוצעו בעסקה.

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

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

מגבלה	Netezza	BigQuery
טבלאות לכל מסד נתונים	32,000	לא מוגבל
עמודות בכל טבלה	1600	10000
גודל שורה מקסימלי	‫64 KB	‫100 MB
אורך השם של העמודה והטבלה	‫128 בייטים	‫16,384 תווי Unicode
שורות לכל טבלה	ללא הגבלה	ללא הגבלה
אורך מקסימלי של בקשת SQL		‫1 MB (אורך מקסימלי של שאילתת SQL רגילה לא פתורה). ‫12 MB (אורך מקסימלי של שאילתת SQL מדור קודם ושל שאילתת SQL רגילה שנפתרה). סטרימינג: ‫10 MB (מגבלת הגודל של בקשת HTTP) ‫10,000 (מספר השורות המקסימלי לכל בקשה)
גודל מקסימלי של בקשה ותגובה		‫10 MB (בקשה) ו-10 GB (תגובה) או ללא הגבלה אם משתמשים בעימוד או ב-Cloud Storage API.
מספר הפעילויות המקסימלי בו-זמנית	‫63 טרנזקציות בו-זמניות של קריאה וכתיבה. ‫2000 חיבורים בו-זמניים לשרת.	‫100 שאילתות בו-זמניות (אפשר להגדיל את המספר הזה באמצעות הזמנת משבצת), 300 בקשות API בו-זמניות לכל משתמש.

המאמרים הבאים

הוראות מפורטות למעבר מ-IBM Netezza ל-BigQuery

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

סוגי נתונים

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

SELECT דוחות

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

פונקציות SQL מובנות

פונקציות

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

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

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

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

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

תחביר DML

INSERT דוחות

UPDATE דוחות

DELETE ודוחות TRUNCATE

MERGE דוחות

תחביר DDL

CREATE TABLE דוחות

DROP דוחות

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

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

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

CREATE PROCEDURE דוחות

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

‫Exception handlers

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

משפטי בקרה

הצהרות אחרות ורכיבי שפה פרוצדורליים

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

הצהרות SQL אחרות

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

טרנזקציות

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

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

המאמרים הבאים

`SELECT` דוחות

`INSERT` דוחות

`UPDATE` דוחות

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

`MERGE` דוחות

`CREATE TABLE` דוחות

`DROP` דוחות

`CREATE PROCEDURE` דוחות