‫Google משתמשת בטכנולוגיית AI כדי לתרגם תוכן לשפה המועדפת עליך. בתרגומים כאלו עשויות להיות שגיאות.

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

מחסן הנתונים 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 בגרסת טרום-השקה (Preview).

סוגי הנתונים

Netezza	BigQuery	הערות
`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`	הסוג `TIMESTAMP` ב-Netezza לא כולל אזור זמן, כמו הסוג `DATETIME` ב-BigQuery.
	`ARRAY`	אין סוג נתונים של מערך ב-Netezza. במקום זאת, סוג המערך מאוחסן בשדה varchar.

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

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

Netezza	BigQuery
`CURRENT_TIMESTAMP` `CURRENT_TIME` למידע מסוג `TIME` ב-Netezza יכולים להיות פרטים שונים של אזור זמן, שמוגדרים באמצעות התחביר `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`	אופרטור NOT ברמת הביט: `~`
`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`	אופרטור NOT של סיביות: `~`
`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 ועל טיפול בסשנים ובטרנזקציות. לדוגמאות, ראו דוגמאות ל-MERGE ב-BigQuery ודוגמאות ל-MERGE ב-Netezza.

תחביר DDL

בקטע הזה נשווה בין תחביר ה-DDL של Netezza לבין זה של BigQuery.

הצהרה של `CREATE TABLE`

Netezza	BigQuery	תיאור
`TEMP` `TEMPORARY`	בעזרת התמיכה של BigQuery ב-DDL, אתם יכולים ליצור טבלה מתוצאות של שאילתה ולציין את תאריך התפוגה שלה בזמן היצירה. לדוגמה, לשלושה ימים: `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`	הקצאת ערך למשתנה.

רכיבי handler של חריגים

ב-Netezza יש תמיכה ב-exception handlers שאפשר להפעיל בתנאי שגיאה מסוימים. ב-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` מצב `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;`	לא נתמך	חזרה על אוסף של שורות.
שליטה איטרטיבית `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 עם מספר הצהרות ומספר שורות

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

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

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

טרנזקציות

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

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

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

ב-Netezza אפשר להשתמש בהצהרה ROLLBACK TRANSACTION כדי לבטל את הטרנזקציה הנוכחית ולהחזיר את כל השינויים שבוצעו בה.

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

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

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

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

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

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

סוגי הנתונים

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

הצהרה של SELECT

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

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

פונקציות

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

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

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

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

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

תחביר DML

הצהרה של INSERT

הצהרה של UPDATE

הצהרות DELETE ו-TRUNCATE

הצהרה של MERGE

תחביר DDL

הצהרה של CREATE TABLE

הצהרה של DROP

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

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

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

הצהרה של CREATE PROCEDURE

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

רכיבי handler של חריגים

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

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

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

הצהרות SQL עם מספר הצהרות ומספר שורות

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

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

טרנזקציות

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

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

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

הצהרה של `SELECT`

הצהרה של `INSERT`

הצהרה של `UPDATE`

הצהרות `DELETE` ו-`TRUNCATE`

הצהרה של `MERGE`

הצהרה של `CREATE TABLE`

הצהרה של `DROP`

הצהרה של `CREATE PROCEDURE`