Se usó la API de Cloud Translation para traducir esta página.

Guía de traducción de SQL de IBM Netezza

El almacenamiento de datos de IBM Netezza está diseñado para funcionar con la sintaxis de SQL específica de Netezza. Netezza SQL se basa en Postgres 7.2. Las secuencias de comandos de SQL escritas para Netezza no se pueden usar en un almacén de datos de BigQuery sin alteraciones porque los dialectos de SQL varían.

En este documento, se detallan las similitudes y diferencias en la sintaxis de SQL entre Netezza y BigQuery en las siguientes áreas:

Tipos de datos
Elementos del lenguaje SQL
Sintaxis de las consultas
Lenguaje de manipulación de datos (DML)
Lenguaje de definición de datos (DDL)
Procedimientos almacenados
Funciones

También puedes usar la traducción de SQL por lotes para migrar tus secuencias de comandos de SQL de forma masiva o la traducción de SQL interactiva a fin de traducir ad hoc. SQL de IBM Netezza/NZPLSQL es compatible con ambas herramientas en la vista previa.

Tipos de datos

Netezza	BigQuery	Notas
`INTEGER/INT/INT4`	`INT64`
`SMALLINT/INT2`	`INT64`
`BYTEINT/INT1`	`INT64`
`BIGINT/INT8`	`INT64`
`DECIMAL`	`NUMERIC`	El tipo de datos `DECIMAL` en Netezza es un alias para el tipo de datos `NUMERIC`.
`NUMERIC`	`NUMERIC` `INT64`
`NUMERIC(p,s)`	`NUMERIC`	El tipo `NUMERIC` en BigQuery no aplica dígitos personalizados ni límites de escalamiento (restricciones) como lo hace Netezza. BigQuery tiene 9 dígitos fijos después del decimal, mientras que Netezza permite una configuración personalizada. En Netezza, la precisión `p` puede variar de 1 a 38 y escalar `s` de 0 a la precisión.
`FLOAT(p)`	`FLOAT64`
`REAL/FLOAT(6)`	`FLOAT64`
`DOUBLE PRECISION/FLOAT(14)`	`FLOAT64`
`CHAR/CHARACTER`	`STRING`	El tipo `STRING` en BigQuery es de longitud variable y no requiere que se establezca una extensión máxima de caracteres de forma manual como Netezza `CHARACTER` y `VARCHAR` requieren. El valor predeterminado de `n` en `CHAR(n)` es 1. El tamaño máximo de la cadena de caracteres es de 64,000.
`VARCHAR`	`STRING`	El tipo `STRING` en BigQuery es de longitud variable y no requiere que se establezca una extensión máxima de caracteres de forma manual como Netezza `CHARACTER` y `VARCHAR` requieren. El tamaño máximo de la cadena de caracteres es de 64,000.
`NCHAR`	`STRING`	El tipo `STRING` en BigQuery se almacena como Unicode con codificación UTF-8 de longitud variable. La longitud máxima es de 16,000 caracteres.
`NVARCHAR`	`STRING`	El tipo `STRING` en BigQuery se almacena como Unicode codificado en UTF-8 de longitud variable. La longitud máxima es de 16,000 caracteres.
`VARBINARY`	`BYTES`
`ST_GEOMETRY`	`GEOGRAPHY`
`BOOLEAN/BOOL`	`BOOL`	El tipo `BOOL` en BigQuery solo puede aceptar `TRUE/FALSE`, a diferencia del tipo `BOOL` en Netezza, que puede aceptar una variedad de valores como `0/1`, `yes/no`, `true/false,` `on/off`.
`DATE`	`DATE`
`TIME`	`TIME`
`TIMETZ/TIME WITH TIME ZONE`	`TIME`	Netezza almacena el tipo de datos `TIME` en UTC y te permite pasar un desplazamiento de UTC mediante la sintaxis `WITH TIME ZONE`. El tipo de datos `TIME` en BigQuery representa una hora que es independiente de cualquier fecha o zona horaria.
`TIMESTAMP`	`DATETIME`	El tipo `TIMESTAMP` de Netezza no incluye una zona horaria, igual que el tipo `DATETIME` de BigQuery.
	`ARRAY`	No hay ningún tipo de datos de array en Netezza. En su lugar, el tipo de array se almacena en un campo de charchar.

Tipos de formato de marca de tiempo y fecha

Para obtener más información sobre el formato de tipo de fecha que usa Netezza SQL, consulta la documentación de los patrones de plantilla de fecha y hora de Netezza. Para obtener más información sobre las funciones de fecha y hora, consulta la documentación de la funciones de fecha y hora de Netezza.

Cuando conviertes los elementos de formato de tipo de fecha de Netezza en GoogleSQL, debes prestar especial atención a las diferencias de zona horaria entre TIMESTAMP y DATETIME, como se resume en la siguiente tabla:

Netezza	BigQuery
`CURRENT_TIMESTAMP` `CURRENT_TIME` información de `TIME` en Netezza puede tener información diferente de la zona horaria, que se define mediante la sintaxis `WITH TIME ZONE`.	Si es posible, usa la función `CURRENT_TIMESTAMP`, que tiene el formato correcto. Sin embargo, el formato de salida no siempre muestra la zona horaria UTC (internamente, BigQuery no tiene una zona horaria). El objeto `DATETIME` en la herramienta de línea de comandos de bq y en la consola de Google Cloud se formatea con un separador `T` según RFC 3339. Sin embargo, en JDBC de Python y Java, se usa un espacio como separador. Usa la función `FORMAT_DATETIME` explícita para definir el formato de fecha correctamente. De lo contrario, se realiza una conversión explícita a una cadena, por ejemplo: `CAST(CURRENT_DATETIME() AS STRING)` Esto también muestra un separador de espacio.
`CURRENT_DATE`	`CURRENT_DATE`
`CURRENT_DATE-3`	BigQuery no admite operaciones aritméticas de datos. En su lugar, usa la función `DATE_ADD`.

Declaración `SELECT`

Por lo general, la declaración SELECT de Netezza es compatible con BigQuery. En la siguiente tabla, se incluye una lista de excepciones:

Netezza BigQuery

Netezza	BigQuery
Una declaración `SELECT` sin cláusula `FROM`	Admite casos especiales como los siguientes: `SELECT 1 UNION ALL SELECT 2;`
SELECT (subquery) AS flag, CASE WHEN flag = 1 THEN ...	En BigQuery, las columnas no pueden hacer referencia al resultado de otras columnas definidas dentro de la misma consulta. Debes duplicar la lógica o mover la lógica a una consulta anidada. Opción 1 SELECT (subquery) AS flag, CASE WHEN (subquery) = 1 THEN ... Opción 2 SELECT q.*, CASE WHEN flag = 1 THEN ... FROM ( SELECT (subquery) AS flag, ... ) AS q

Una declaración SELECT sin cláusula FROM

Admite casos especiales como los siguientes:

SELECT 1 UNION ALL SELECT 2;

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

En BigQuery, las columnas no pueden hacer referencia al resultado de otras columnas definidas dentro de la misma consulta. Debes duplicar la lógica o mover la lógica a una consulta anidada.

Opción 1

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

Opción 2

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

Operadores de comparación

Netezza	BigQuery	Descripción
`exp = exp2`	`exp = exp2`	Igual
`exp <= exp2`	`exp <= exp2`	Menor o igual que
`exp < exp2`	`exp < exp2`	Inferior a
`exp <> exp2` `exp != exp2`	`exp <> exp2` `exp != exp2`	No igual
`exp >= exp2`	`exp >= exp2`	Mayor o igual que
`exp > exp2`	`exp > exp2`	Mayor que

Funciones de SQL integradas

Netezza	BigQuery	Descripción
`CURRENT_DATE`	`CURRENT_DATE`	Obtén la fecha actual (año, mes y día).
`CURRENT_TIME`	`CURRENT_TIME`	Obtén la hora actual con fracción.
`CURRENT_TIMESTAMP`	`CURRENT_TIMESTAMP`	Obtén la fecha y hora actuales del sistema en el segundo completo más cercano.
`NOW`	`CURRENT_TIMESTAMP`	Obtén la fecha y hora actuales del sistema en el segundo completo más cercano.
`COALESCE(exp, 0)`	`COALESCE(exp, 0)`	Reemplaza `NULL` por cero.
`NVL(exp, 0)`	`IFNULL(exp, 0)`	Reemplaza `NULL` por cero.
`EXTRACT(DOY FROM timestamp_expression)`	`EXTRACT(DAYOFYEAR FROM timestamp_expression)`	Muestra el número de días desde el comienzo del año.
`ADD_MONTHS(date_expr, num_expr)`	`DATE_ADD(date, INTERVAL k MONTH)`	Agrega meses a una fecha.
`DURATION_ADD(date, k)`	`DATE_ADD(date, INTERVAL k DAY)`	Realiza la adición a las fechas.
`DURATION_SUBTRACT(date, k)`	`DATE_SUB(date, INTERVAL k DAY)`	Realiza la resta de las fechas.
`str1 \|\| str2`	`CONCAT(str1, str2)`	Concatena cadenas.

Funciones

En esta sección, se comparan las funciones de Netezza y BigQuery.

Funciones de agregación

Netezza	BigQuery
	`ANY_VALUE`
	`APPROX_COUNT_DISTINCT`
	`APPROX_QUANTILES`
	`APPROX_TOP_COUNT`
	`APPROX_TOP_SUM`
`AVG`	`AVG`
`intNand`	`BIT_AND`
`intNnot`	Operador NOT a nivel de bits: `~`
`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`

Funciones analíticas

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`	Operador NOT a nivel de bits: `~`
`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`

Funciones de fecha y hora

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`

Funciones de string

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`

Funciones matemáticas

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)`

Sintaxis de DML

En esta sección, se compara la sintaxis de DML de Netezza y BigQuery.

Declaración `INSERT`

Netezza BigQuery

Netezza	BigQuery
INSERT INTO table VALUES (...);	INSERT INTO table (...) VALUES (...); Netezza ofrece una palabra clave `DEFAULT` y otras restricciones para las columnas. En BigQuery, omitir los nombres de las columnas en la declaración `INSERT` solo es válido si se proporcionan todas las columnas.
INSERT INTO table (...) VALUES (...); INSERT INTO table (...) VALUES (...);	INSERT INTO table VALUES (), (); BigQuery impone cuotas de DML, que restringen la cantidad de declaraciones DML que puedes ejecutar a diario. Para aprovechar al máximo tu cuota, considera los siguientes enfoques: Combina varias filas en una sola declaración `INSERT`, en lugar de una fila por operación `INSERT`. Combina varias declaraciones DML (incluida una declaración `INSERT`) con una declaración `MERGE`. Usa una declaración `CREATE TABLE ... AS SELECT` para crear y propagar tablas nuevas.

INSERT INTO table VALUES (...);

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

Netezza ofrece una palabra clave DEFAULT y otras restricciones para las columnas. En BigQuery, omitir los nombres de las columnas en la declaración INSERT solo es válido si se proporcionan todas las columnas.

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

INSERT INTO table VALUES (), ();

BigQuery impone cuotas de DML, que restringen la cantidad de declaraciones DML que puedes ejecutar a diario. Para aprovechar al máximo tu cuota, considera los siguientes enfoques:

Combina varias filas en una sola declaración INSERT, en lugar de una fila por operación INSERT.

Combina varias declaraciones DML (incluida una declaración INSERT) con una declaración MERGE.

Usa una declaración CREATE TABLE ... AS SELECT para crear y propagar tablas nuevas.

Las secuencias de comandos del DML en BigQuery tienen una semántica de coherencia apenas diferente de la que tienen las declaraciones equivalentes de Netezza. Además, ten en cuenta que BigQuery no ofrece restricciones además de NOT NULL.

Para obtener una descripción general del aislamiento de instantáneas y el control de sesiones y transacciones, consulta Garantías de coherencia y aislamiento de transacción.

Declaración `UPDATE`

En Netezza, la cláusula WHERE es opcional, pero en BigQuery es necesaria.

Netezza BigQuery

Netezza	BigQuery
UPDATE tbl SET tbl.col1=val1;	No se admite sin la cláusula `WHERE`. Usa una cláusula `WHERE true` para actualizar todas las filas.
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;

No se admite sin la cláusula WHERE. Usa una cláusula WHERE true para actualizar todas las filas.

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;

Para ver ejemplos, consulta Ejemplos de UPDATE.

Debido a las cuotas DML, te recomendamos que uses las declaraciones MERGE más grandes en lugar de varias declaraciones UPDATE y INSERT individuales. Las secuencias de comandos del DML en BigQuery tienen una semántica de coherencia apenas diferente de la que tienen las declaraciones equivalentes de Netezza. Para obtener una descripción general del aislamiento de instantáneas y el control de sesiones y transacciones, consulta Garantías de coherencia y aislamiento de transacción.

Declaraciones `DELETE` y `TRUNCATE`

Las declaraciones DELETE y TRUNCATE son alternativas para quitar filas de una tabla sin afectar el esquema ni los índices de esta. La declaración TRUNCATE tiene el mismo efecto que la declaración DELETE, pero es mucho más rápida que la declaración DELETE para tablas grandes. La declaración TRUNCATE es compatible con Netezza, pero no con BigQuery. Sin embargo, puedes usar declaraciones DELETE en Netezza y BigQuery.

En BigQuery, la declaración DELETE debe tener una cláusula WHERE. En Netezza, la cláusula WHERE es opcional. Si no se especifica la cláusula WHERE, se borran todas las filas de la tabla Netezza.

Netezza BigQuery Descripción

Netezza	BigQuery	Descripción
BEGIN; LOCK TABLE A IN EXCLUSIVE MODE; DELETE FROM A; INSERT INTO A SELECT * FROM B; COMMIT;	El equivalente a una transacción es reemplazar el contenido de una tabla por el resultado de la consulta. Puedes hacerlo con una operación de `query` o una operación de copiado(`cp`) operation. bq query \ --replace \ --destination_table \ tableA \ 'SELECT * \ FROM tableB \ WHERE ...' bq cp \ -f tableA tableB	Reemplaza el contenido de una tabla por los resultados de una consulta.
DELETE FROM database.table	DELETE FROM table WHERE TRUE;	En Netezza, cuando se ejecuta una instrucción de borrado, las filas no se borran de forma física, sino que solo se marcan para su eliminación. Ejecutar los comandos `GROOM TABLE` o `nzreclaim` más adelante quita las filas marcadas para la eliminación y recupera el espacio en el disco correspondiente.
`GROOM TABLE`		Netezza usa el comando `GROOM TABLE` con el objetivo de recuperar espacio en el disco mediante la eliminación de las filas marcadas para su eliminación.

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

El equivalente a una transacción es reemplazar el contenido de una tabla por el resultado de la consulta. Puedes hacerlo con una operación de query o una operación de copiado(cp) operation.

bq query \

--replace \

--destination_table \

tableA \

'SELECT * \

FROM tableB \

WHERE ...'

bq cp \

-f tableA tableB

Reemplaza el contenido de una tabla por los resultados de una consulta.

DELETE FROM database.table

DELETE FROM table WHERE TRUE;

En Netezza, cuando se ejecuta una instrucción de borrado, las filas no se borran de forma física, sino que solo se marcan para su eliminación. Ejecutar los comandos GROOM TABLE o nzreclaim más adelante quita las filas marcadas para la eliminación y recupera el espacio en el disco correspondiente.

GROOM TABLE Netezza usa el comando GROOM TABLE con el objetivo de recuperar espacio en el disco mediante la eliminación de las filas marcadas para su eliminación.

Declaración `MERGE`

Una declaración MERGE debe coincidir como máximo con una fila de origen para cada fila de destino. Las secuencias de comandos del DML en BigQuery tienen una semántica de coherencia apenas diferente de la que tienen las declaraciones equivalentes de Netezza. Para obtener una descripción general del aislamiento de instantáneas y el control de sesiones y transacciones, consulta Garantías de coherencia y aislamiento de transacción. Para ver ejemplos, consulta Ejemplos de BigQuery MERGE y Ejemplos de Netezza MERGE.

Sintaxis del DDL

En esta sección, se compara la sintaxis de DDL de Netezza y BigQuery.

Declaración `CREATE TABLE`

Netezza	BigQuery	Descripción
`TEMP` `TEMPORARY`	Con la compatibilidad con DDL de BigQuery, puedes crear una tabla a partir de los resultados de una consulta y especificar su vencimiento en el momento de la creación. Por ejemplo, durante tres días: `CREATE TABLE` `'fh-bigquery.public_dump.vtemp'` `OPTIONS`( `expiration_timestamp=TIMESTAMP_ADD(CURRENT_TIMESTAMP(),` `INTERVAL 3 DAY))`	Crea tablas temporales para una sesión.
`ZONE MAPS`	No compatible.	Búsqueda rápida de la condición `WHERE`.
`DISTRIBUTE ON`	`PARTITION BY`	Partición. Esta no es una traducción directa. `DISTRIBUTE ON` comparte datos entre nodos, por lo general, con una clave única para una distribución uniforme, mientras que `PARTITION BY` reduce los datos a segmentos.
`ORGANIZE ON`	`CLUSTER BY`	Netezza y BigQuery admiten hasta cuatro claves para el agrupamiento en clústeres. Las tablas base agrupadas en clústeres (CBT) de Netezza proporcionan la misma prioridad a cada una de las columnas de agrupamiento en clústeres. BigQuery otorga prioridad a la primera columna en la que se agrupa la tabla, seguida de la segunda, y así sucesivamente.
`ROW SECURITY`	`Authorized View`	Seguridad a nivel de la fila
`CONSTRAINT`	No compatible	Comprueba las restricciones.

Declaración `DROP`

Netezza	BigQuery	Descripción
`DROP TABLE`	`DROP TABLE`
`DROP DATABASE`	`DROP DATABASE`
`DROP VIEW`	`DROP VIEW`

Atributos y opciones de columnas

Netezza	BigQuery	Descripción
`NULL` `NOT NULL`	`NULLABLE` `REQUIRED`	Especifica si la columna puede contener valores `NULL`.
`REFERENCES`	No compatible	Especifica la restricción de la columna.
`UNIQUE`	No compatible	Cada valor de la columna debe ser único.
`DEFAULT`	No compatible	Valor predeterminado para todos los valores de la columna.

Tablas temporales

Netezza admite tablas TEMPORARY que existen durante la duración de una sesión.

Sigue estos pasos para compilar una tabla temporal en BigQuery:

Cree un conjunto de datos con un tiempo de actividad corto (por ejemplo, 12 horas).
Crea la tabla temporal en el conjunto de datos, con un prefijo de nombre de tabla de temp. Por ejemplo, para crear una tabla que venza en una hora, haz lo siguiente:
```
CREATE TABLE temp.name (col1, col2, ...)
OPTIONS(expiration_timestamp = TIMESTAMP_ADD(CURRENT_TIMESTAMP(),
INTERVAL 1 HOUR));
```
Empieza a leer y escribir desde la tabla temporal.

También puedes quitar los duplicados de forma independiente para encontrar errores en los sistemas posteriores.

Ten en cuenta que BigQuery no es compatible con las columnas DEFAULT y IDENTITY (secuencias).

Instrucciones de SQL de procedimiento

Netezza usa el lenguaje de programación NZPLSQL para trabajar con procedimientos almacenados. NZPLSQL se basa en el lenguaje PL/pgSQL de Postgres. En esta sección, se describe cómo convertir las instrucciones de SQL de procedimiento que se usan en procedimientos, funciones y activadores almacenados de Netezza a BigQuery.

Declaración `CREATE PROCEDURE`

Netezza y BigQuery admiten la creación de procedimientos almacenados mediante la declaración CREATE PROCEDURE. Para obtener más información, consulta Trabaja con procedimientos almacenados de SQL.

Declaración y asignación de variables

Netezza	BigQuery	Descripción
`DECLARE var datatype(len) [DEFAULT value];`	`DECLARE`	Declarar la variable.
`SET var = value;`	`SET`	Asigna valor a la variable

Controladores de excepciones

Netezza admite controladores de excepciones que se pueden activar para ciertas condiciones de error. BigQuery no es compatible con los controladores de condiciones.

Netezza	BigQuery	Descripción
`EXCEPTION`	No compatible	Declara el controlador de excepciones de SQL para detectar errores generales.

Instrucciones de SQL dinámicas

Netezza admite consultas en SQL dinámicas dentro de procedimientos almacenados. BigQuery no admite instrucciones en SQL dinámicas.

Netezza	BigQuery	Descripción
`EXECUTE IMMEDIATE` `sql_str;`	`EXECUTE IMMEDIATE` `sql_str;`	Ejecuta SQL dinámico.

Instrucciones de flujo de control

Netezza	BigQuery	Descripción
`IF THEN ELSE STATEMENT` `IF` condición `THEN ...` `ELSE ...` `END IF;`	`IF` condición `THEN ...` `ELSE ...` `END IF;`	Ejecuta de manera condicional.
Control iterativo `FOR var AS SELECT ...` `DO` stmts `END FOR;` `FOR var AS cur CURSOR` `FOR SELECT ...` `DO stmts END FOR;`	No compatible	Itera en una colección de filas.
Control iterativo `LOOP stmts END LOOP;`	`LOOP` `sql_statement_list END LOOP;`	Bloque de bucle de declaraciones.
`EXIT WHEN`	`BREAK`	Salir de un procedimiento.
`WHILE condition LOOP`	`WHILE` condición `DO ...` `END WHILE`	Ejecuta un bucle de declaraciones hasta que falle una condición de tiempo.

Otras declaraciones y elementos del lenguaje de procedimiento

Netezza	BigQuery	Descripción
`CALL` `proc(param,...)`	No compatible	Ejecuta un procedimiento.
`EXEC` `proc(param,...)`	No compatible	Ejecuta un procedimiento.
`EXECUTE` `proc(param,...)`	No compatible	Ejecuta un procedimiento.

Instrucciones de SQL de varias instrucciones y varias líneas

Netezza y BigQuery admiten transacciones (sesiones) y, por lo tanto, admiten declaraciones separadas por punto y coma que se ejecutan juntas de manera coherente. Para obtener más información, consulta Transacciones de varias declaraciones.

Otras instrucciones de SQL

Netezza	BigQuery	Descripción
`GENERATE STATISTICS`		Genera estadísticas para todas las tablas en la base de datos actual.
`GENERATE STATISTICS ON table_name`		Genera estadísticas para una tabla específica.
`GENERATE STATISTICS ON table_name(col1,col4)`	Usa funciones estadísticas, como `MIN, MAX, AVG,`, etc., usa la IU o la API de Cloud Data Loss Prevention.	Genera estadísticas para columnas específicas en una tabla.
`GENERATE STATISTICS ON table_name`	`APPROX_COUNT_DISTINCT(col)`	Muestra la cantidad de valores únicos para las columnas.
`INSERT INTO table_name`	`INSERT INTO table_name`	Inserta una fila.
`LOCK TABLE` `table_name FOR` `EXCLUSIVE;`	No compatible	Bloquea fila.
`SET SESSION` `CHARACTERISTICS AS` `TRANSACTION ISOLATION LEVEL` ...	BigQuery siempre usa el aislamiento de instantáneas. Para obtener más información, consulta Garantías de coherencia y aislamiento de transacción.	Define el nivel de aislamiento de la transacción.
`BEGIN TRANSACTION` `END TRANSACTION` `COMMIT`	BigQuery siempre usa el aislamiento de instantáneas. Para obtener más información, consulta Garantías de coherencia y aislamiento de transacción.	Define el límite de transacción para las solicitudes de varias declaraciones.
`EXPLAIN` ...	No compatible. Funciones similares en el plan de consultas y el cronograma	Muestra el plan de consultas para una declaración `SELECT`.
Metadatos de vistas de usuario metadatos de vistas del sistema	`SELECT` `* EXCEPT(is_typed)` `FROM` `mydataset.INFORMATION_SCHEMA.TABLES;` BigQueryEsquema de información	Consulta objetos en la base de datos

Garantías de coherencia y aislamiento de transacción

Tanto Teradata como BigQuery son atómicos, es decir, cumplen con el estándar ACID en un nivel por transformación en muchas filas. Por ejemplo, una operación MERGE es atómica por completo, incluso con varios valores insertados.

Transacciones

Netezza acepta sintácticamente los cuatro modos de aislamiento de transacción de ANSI SQL. Sin embargo, sin importar el modo que se especifique, solo se usa el modo SERIALIZABLE, que proporciona el mayor nivel de coherencia posible. Este modo también evita lecturas no sincronizadas, no repetibles y fantasmas entre transacciones simultáneas. Netezza no usa el bloqueo convencional para aplicar la coherencia. En su lugar, usa la verificación de dependencia de serialización, una forma de control de simultaneidad optimista para revertir automáticamente la última transacción cuando dos transacciones intentan modificar los mismos datos.

BigQuery también admite transacciones. BigQuery ayuda a garantizar el control de simultaneidad optimista (gana el primero en confirmarse) con el aislamiento de instantáneas, de modo que una consulta lea los últimos datos que se confirmaron antes de comenzar la consulta. Este enfoque garantiza el mismo nivel de coherencia por fila, por transformación y entre filas dentro de la misma declaración DML y evita los interbloqueos. En el caso de varias actualizaciones de DML en la misma tabla, BigQuery cambia al control de simultaneidad pesimista. Los trabajos de carga pueden ejecutarse de forma independiente por completo y agregarse a las tablas.

Revertir

Netezza admite la declaración ROLLBACK para anular la transacción actual y revertir todos los cambios realizados en la transacción.

En BigQuery, puedes usar la sentencia ROLLBACK TRANSACTION.

Límites de bases de datos

Límite	Netezza	BigQuery
Tablas por base de datos	32,000	Sin restricciones
Columnas por tabla	1600	10000
Tamaño máximo de fila	64 KB	100 MB
Longitud del nombre de la columna y la tabla	128 bytes	16,384 caracteres Unicode
Filas por tabla	Ilimitado	Ilimitado
Longitud máxima de la solicitud de SQL		1 MB (extensión máxima sin resolver de la consulta de SQL estándar). 12 MB (extensión máximaresuelta de la consulta en SQL estándar y heredado). Transmisión: 10 MB (límite de tamaño de la solicitud HTTP) 10,000 (máximo de filas por solicitud)
Tamaño máximo de solicitudes y respuestas		10 MB (solicitud) y 10 GB (respuesta) o casi sin límite si usas la paginación o la API de Cloud Storage.
Cantidad máxima de sesiones simultáneas	63 transacciones de lectura y escritura simultáneas 2000 conexiones simultáneas al servidor.	100 consultas simultáneas (se pueden generar con una reserva de ranura) y 300 solicitudes a la API simultáneas por usuario

¿Qué sigue?

Obtén instrucciones paso a paso para migrar de IBM Netezza a BigQuery.

Guía de traducción de SQL de IBM Netezza

Tipos de datos

Tipos de formato de marca de tiempo y fecha

Declaración SELECT

Operadores de comparación

Funciones de SQL integradas

Funciones

Funciones de agregación

Funciones analíticas

Funciones de fecha y hora

Funciones de string

Funciones matemáticas

Sintaxis de DML

Declaración INSERT

Declaración UPDATE

Declaraciones DELETE y TRUNCATE

Declaración MERGE

Sintaxis del DDL

Declaración CREATE TABLE

Declaración DROP

Atributos y opciones de columnas

Tablas temporales

Instrucciones de SQL de procedimiento

Declaración CREATE PROCEDURE

Declaración y asignación de variables

Controladores de excepciones

Instrucciones de SQL dinámicas

Instrucciones de flujo de control

Otras declaraciones y elementos del lenguaje de procedimiento

Instrucciones de SQL de varias instrucciones y varias líneas

Otras instrucciones de SQL

Garantías de coherencia y aislamiento de transacción

Transacciones

Revertir

Límites de bases de datos

¿Qué sigue?

Declaración `SELECT`

Declaración `INSERT`

Declaración `UPDATE`

Declaraciones `DELETE` y `TRUNCATE`

Declaración `MERGE`

Declaración `CREATE TABLE`

Declaración `DROP`

Declaración `CREATE PROCEDURE`