Esta página se ha traducido con Cloud Translation API.

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

El almacenamiento de datos de IBM Netezza se ha diseñado para funcionar con la sintaxis de SQL específica de Netezza. Netezza SQL se basa en Postgres 7.2. Los scripts de SQL escritos para Netezza no se pueden usar en un almacén de datos de BigQuery sin modificaciones, ya que los dialectos de SQL varían.

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

Tipos de datos
Elementos del lenguaje SQL
Sintaxis de consulta
Lenguaje de manipulación de datos (DML)
Lenguaje de definición de datos (DDL)
Procedimientos almacenados
Functions

También puedes usar la traducción de SQL por lotes para migrar tus secuencias de comandos SQL en bloque o la traducción de SQL interactiva para traducir consultas específicas. IBM Netezza SQL/NZPLSQL es compatible con ambas herramientas en versión preliminar.

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` de Netezza es un alias del tipo de datos `NUMERIC`.
`NUMERIC`	`NUMERIC` `INT64`
`NUMERIC(p,s)`	`NUMERIC`	El tipo `NUMERIC` de BigQuery no aplica límites de dígitos ni de escala personalizados (restricciones) como Netezza. BigQuery tiene 9 dígitos fijos después de la coma, mientras que Netezza permite una configuración personalizada. En Netezza, la precisión `p` puede oscilar entre 1 y 38, y la escala `s` entre 0 y la precisión.
`FLOAT(p)`	`FLOAT64`
`REAL/FLOAT(6)`	`FLOAT64`
`DOUBLE PRECISION/FLOAT(14)`	`FLOAT64`
`CHAR/CHARACTER`	`STRING`	El tipo `STRING` de BigQuery tiene una longitud variable y no requiere que se defina manualmente una longitud máxima de caracteres, como sí ocurre con los tipos `CHARACTER` y `VARCHAR` de Netezza. 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` de BigQuery tiene una longitud variable y no requiere que se defina manualmente una longitud máxima de caracteres, como sí ocurre con los tipos `CHARACTER` y `VARCHAR` de Netezza. El tamaño máximo de la cadena de caracteres es de 64.000.
`NCHAR`	`STRING`	El tipo `STRING` de BigQuery se almacena como Unicode codificado en UTF-8 de longitud variable. La longitud máxima es de 16.000 caracteres.
`NVARCHAR`	`STRING`	El tipo `STRING` de 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` de BigQuery solo puede aceptar `TRUE/FALSE`, a diferencia del tipo `BOOL` de Netezza, que puede aceptar varios valores, como `0/1`, `yes/no`, `true/false,` y `on/off`.
`DATE`	`DATE`
`TIME`	`TIME`
`TIMETZ/TIME WITH TIME ZONE`	`TIME`	Netezza almacena el tipo de datos `TIME` en UTC y te permite transferir un desfase desde UTC mediante la sintaxis `WITH TIME ZONE`. El tipo de datos `TIME` de BigQuery representa una hora independiente de cualquier fecha o zona horaria.
`TIMESTAMP`	`DATETIME`	El tipo `TIMESTAMP` de Netezza no incluye una zona horaria, al igual que el tipo `DATETIME` de BigQuery.
	`ARRAY`	No hay ningún tipo de datos de matriz en Netezza. El tipo de array se almacena en un campo varchar.

Formato de tipo de fecha y hora

Para obtener más información sobre el formato del tipo de fecha que usa Netezza SQL, consulta la documentación sobre 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 sobre las funciones de fecha y hora de Netezza.

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

Netezza	BigQuery
`CURRENT_TIMESTAMP` `CURRENT_TIME` La información de `TIME` de Netezza puede tener información de zona horaria diferente, 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` de la herramienta de línea de comandos bq y de la consolaGoogle Cloud se formatea con un separador `T` según el RFC 3339. Sin embargo, en Python y Java JDBC, se usa un espacio como separador. Usa la función explícita `FORMAT_DATETIME` para definir el formato de fecha correctamente. De lo contrario, se hace una conversión explícita a una cadena, por ejemplo: `CAST(CURRENT_DATETIME() AS STRING)` Esto también devuelve un separador de espacio.
`CURRENT_DATE`	`CURRENT_DATE`
`CURRENT_DATE-3`	BigQuery no admite operaciones aritméticas con datos. En su lugar, usa la función `DATE_ADD`.

`SELECT` declaración

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

Netezza BigQuery

Netezza	BigQuery
Una instrucció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 a la salida de otras columnas definidas en la misma consulta. Debes duplicar la lógica o moverla 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 instrucció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 a la salida de otras columnas definidas en la misma consulta. Debes duplicar la lógica o moverla 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`	Inferior o igual a
`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`	Superior a

Funciones de SQL integradas

Netezza	BigQuery	Descripción
`CURRENT_DATE`	`CURRENT_DATE`	Obtiene la fecha actual (año, mes y día).
`CURRENT_TIME`	`CURRENT_TIME`	Obtiene la hora actual con fracciones.
`CURRENT_TIMESTAMP`	`CURRENT_TIMESTAMP`	Obtiene la fecha y la hora actuales del sistema, con una precisión de un segundo.
`NOW`	`CURRENT_TIMESTAMP`	Obtiene la fecha y la hora actuales del sistema, redondeadas al segundo más próximo.
`COALESCE(exp, 0)`	`COALESCE(exp, 0)`	Sustituye `NULL` por cero.
`NVL(exp, 0)`	`IFNULL(exp, 0)`	Sustituye `NULL` por cero.
`EXTRACT(DOY FROM timestamp_expression)`	`EXTRACT(DAYOFYEAR FROM timestamp_expression)`	Devuelve el número de días desde el principio del año.
`ADD_MONTHS(date_expr, num_expr)`	`DATE_ADD(date, INTERVAL k MONTH)`	Añadir meses a una fecha.
`DURATION_ADD(date, k)`	`DATE_ADD(date, INTERVAL k DAY)`	Realiza sumas en fechas.
`DURATION_SUBTRACT(date, k)`	`DATE_SUB(date, INTERVAL k DAY)`	Resta fechas.
`str1 \|\| str2`	`CONCAT(str1, str2)`	Concatenar cadenas.

Functions

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 bit a bit: `~`
`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 bit a bit: `~`
`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 cadena

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 DML de Netezza y BigQuery.

`INSERT` declaración

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, solo se pueden omitir los nombres de las columnas en la instrucción `INSERT` 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 el número de declaraciones de DML que puedes ejecutar al día. Para aprovechar al máximo tu cuota, puedes seguir estos enfoques: Combina varias filas en una sola instrucción `INSERT`, en lugar de una fila por instrucción `INSERT`. Combina varias instrucciones DML (incluida una instrucción `INSERT`) con una instrucción `MERGE`. Usa una instrucción `CREATE TABLE ... AS SELECT` para crear y rellenar tablas.

INSERT INTO table VALUES (...);

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

Netezza ofrece una palabra clave DEFAULT y otras restricciones para las columnas. En BigQuery, solo se pueden omitir los nombres de las columnas en la instrucción INSERT 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 el número de declaraciones de DML que puedes ejecutar al día. Para aprovechar al máximo tu cuota, puedes seguir estos enfoques:

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

Combina varias instrucciones DML (incluida una instrucción INSERT) con una instrucción MERGE.

Usa una instrucción CREATE TABLE ... AS SELECT para crear y rellenar tablas.

Las secuencias de comandos DML de BigQuery tienen una semántica de coherencia ligeramente diferente a las instrucciones equivalentes de Netezza. Ten en cuenta que BigQuery no ofrece restricciones aparte de NOT NULL.

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

`UPDATE` declaración

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 la sección Ejemplos de UPDATE.

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

`DELETE` y `TRUNCATE`

Las instrucciones DELETE y TRUNCATE son dos formas de eliminar filas de una tabla sin afectar al esquema ni a los índices de la tabla. La instrucción TRUNCATE tiene el mismo efecto que la instrucción DELETE, pero es mucho más rápida que la instrucción DELETE en el caso de las tablas grandes. La instrucción TRUNCATE se admite en Netezza, pero no en BigQuery. Sin embargo, puedes usar instrucciones DELETE tanto en Netezza como en BigQuery.

En BigQuery, la instrucció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 eliminan todas las filas de la tabla de 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;	Sustituir el contenido de una tabla por el resultado de una consulta es el equivalente a una transacción. Puedes hacerlo con una `query` o con una copia (`cp`) de la operación. bq query \ --replace \ --destination_table \ tableA \ 'SELECT * \ FROM tableB \ WHERE ...' bq cp \ -f tableA tableB	Sustituir 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 eliminación, las filas no se eliminan físicamente, sino que solo se marcan para su eliminación. Si ejecutas los comandos `GROOM TABLE` o `nzreclaim` más adelante, se eliminarán las filas marcadas para su eliminación y se recuperará el espacio en disco correspondiente.
`GROOM TABLE`		Netezza usa el comando `GROOM TABLE` para recuperar espacio en disco eliminando las filas marcadas para su eliminación.

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

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

bq query \

--replace \

--destination_table \

tableA \

'SELECT * \

FROM tableB \

WHERE ...'

bq cp \

-f tableA tableB

Sustituir 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 eliminación, las filas no se eliminan físicamente, sino que solo se marcan para su eliminación. Si ejecutas los comandos GROOM TABLE o nzreclaim más adelante, se eliminarán las filas marcadas para su eliminación y se recuperará el espacio en disco correspondiente.

GROOM TABLE Netezza usa el comando GROOM TABLE para recuperar espacio en disco eliminando las filas marcadas para su eliminación.

`MERGE` declaración

Una instrucción MERGE debe coincidir con una fila de origen como máximo por cada fila de destino. Los scripts de DML de BigQuery tienen una semántica de coherencia ligeramente diferente a las instrucciones equivalentes de Netezza. Para obtener una descripción general del aislamiento de instantáneas y de la gestión de sesiones y transacciones, consulta Garantías de coherencia y aislamiento de transacciones. Para ver ejemplos, consulta los ejemplos de MERGE BigQuery y los ejemplos de MERGE Netezza.

Sintaxis de DDL

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

`CREATE TABLE` declaración

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, para tres días: `CREATE TABLE` `'my-project.public_dump.vtemp'` `OPTIONS`( `expiration_timestamp=TIMESTAMP_ADD(CURRENT_TIMESTAMP(),` `INTERVAL 3 DAY))`	Crea tablas temporales para una sesión.
`ZONE MAPS`	No es compatible.	Búsqueda rápida de la condición `WHERE`.
`DISTRIBUTE ON`	`PARTITION BY`	Particiones. No es una traducción directa. `DISTRIBUTE ON` comparte datos entre nodos, normalmente con una clave única para que la distribución sea uniforme, mientras que `PARTITION BY` elimina datos en segmentos.
`ORGANIZE ON`	`CLUSTER BY`	Tanto Netezza como BigQuery admiten hasta cuatro claves para la agrupación en clústeres. Las tablas base agrupadas (CBT) de Netezza proporcionan la misma precedencia a cada una de las columnas de agrupamiento. BigQuery da prioridad a la primera columna en la que se agrupa la tabla, seguida de la segunda columna y así sucesivamente.
`ROW SECURITY`	`Authorized View`	Seguridad a nivel de fila.
`CONSTRAINT`	No compatible	Comprueba las restricciones.

`DROP` declaración

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

Opciones y atributos de columna

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 de todos los valores de la columna.

Tablas temporales

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

Para crear una tabla temporal en BigQuery, haz lo siguiente:

Crea un conjunto de datos con un tiempo de vida breve (por ejemplo, 12 horas).
Crea la tabla temporal en el conjunto de datos con el prefijo temp. Por ejemplo, para crear una tabla que caduque 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 en la tabla temporal.

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

Ten en cuenta que BigQuery no admite columnas DEFAULT y IDENTITY (secuencias).

Declaraciones SQL procedimentales

Netezza usa el lenguaje de scripting 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 almacenados, funciones y activadores de Netezza a BigQuery.

`CREATE PROCEDURE` declaración

Tanto Netezza como BigQuery admiten la creación de procedimientos almacenados mediante la instrucción CREATE PROCEDURE. Para obtener más información, consulta Trabajar con procedimientos almacenados de SQL.

Declaración y asignación de variables

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

Controladores de excepciones

Netezza admite controladores de excepciones que se pueden activar en determinadas condiciones de error. BigQuery no admite controladores de condiciones.

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

Instrucciones SQL dinámicas

Netezza admite consultas de SQL dinámicas en procedimientos almacenados. BigQuery no admite instrucciones 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` condition `THEN ...` `ELSE ...` `END IF;`	`IF` condition `THEN ...` `ELSE ...` `END IF;`	Ejecutar condicionalmente.
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 instrucciones de bucle.
`EXIT WHEN`	`BREAK`	Salir de un procedimiento.
`WHILE condition LOOP`	`WHILE` condition `DO ...` `END WHILE`	Ejecuta un bucle de instrucciones hasta que falle una condición while.

Otras declaraciones y elementos de lenguaje procedimental

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

Instrucciones SQL de varias líneas y con varias instrucciones

Tanto Netezza como BigQuery admiten transacciones (sesiones) y, por lo tanto, admiten instrucciones separadas por puntos y comas que se ejecutan de forma coherente. Para obtener más información, consulta el artículo sobre las transacciones con varias declaraciones.

Otras instrucciones SQL

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

Garantías de coherencia y aislamiento de transacciones

Tanto Netezza como BigQuery son atómicos, es decir, cumplen los requisitos de ACID a nivel de mutación en muchas filas. Por ejemplo, una operación MERGE es completamente atómica, incluso con varios valores insertados.

Transacciones

Netezza acepta sintácticamente los cuatro modos de aislamiento de transacciones de ANSI SQL. Sin embargo, independientemente del modo que se especifique, solo se usa el modo SERIALIZABLE, que proporciona el mayor nivel de coherencia posible. Este modo también evita lecturas sucias, no repetibles y fantasma entre transacciones simultáneas. Netezza no usa el bloqueo convencional para aplicar la coherencia. En su lugar, usa la comprobación de dependencias de serialización, una forma de control de concurrencia 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 asegurar el control de simultaneidad optimista (la primera confirmación tiene prioridad) con el aislamiento de la instantánea, en el que una consulta lee los últimos datos confirmados antes de que empiece la consulta. Este enfoque garantiza el mismo nivel de coherencia por fila y por mutación, así como entre las filas de la misma instrucción DML, pero evita los interbloqueos. En el caso de que se realicen varias actualizaciones de DML en la misma tabla, BigQuery cambia al control de concurrencia pesimista. Las tareas de carga se pueden ejecutar de forma completamente independiente y añadir datos a las tablas.

Restauración

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

En BigQuery, puedes usar la instrucción ROLLBACK TRANSACTION.

Límites de las bases de datos

Límite	Netezza	BigQuery
Tablas por base de datos	32.000	Sin restricción
Columnas por tabla	1600	10000
Tamaño máximo de las filas	64 KB	100 MB
Longitud del nombre de la columna y de la tabla	128 bytes	16.384 caracteres Unicode
Filas por tabla	Ilimitado	Ilimitado
Longitud máxima de la solicitud SQL		1 MB (longitud máxima de las consultas de SQL estándar sin resolver). 12 MB (longitud máxima de las consultas de SQL antiguo y estándar resueltas). Streaming: 10 MB (límite de tamaño de la solicitud HTTP) 10.000 (máximo de filas por solicitud)
Tamaño máximo de solicitud y respuesta		10 MB (solicitud) y 10 GB (respuesta) o prácticamente ilimitado si se usa la paginación o la API Cloud Storage.
Número máximo de sesiones simultáneas	63 transacciones simultáneas de lectura y escritura. 2000 conexiones simultáneas al servidor.	100 consultas simultáneas (se puede aumentar con la reserva de espacio), 300 solicitudes a la API simultáneas por usuario.

Siguientes pasos

Consulta las instrucciones detalladas para migrar de IBM Netezza a BigQuery.

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

Tipos de datos

Formato de tipo de fecha y hora

SELECT declaración

Operadores de comparación

Funciones de SQL integradas

Functions

Funciones de agregación

Funciones analíticas

Funciones de fecha y hora

Funciones de cadena

Funciones matemáticas

Sintaxis de DML

INSERT declaración

UPDATE declaración

DELETE y TRUNCATE

MERGE declaración

Sintaxis de DDL

CREATE TABLE declaración

DROP declaración

Opciones y atributos de columna

Tablas temporales

Declaraciones SQL procedimentales

CREATE PROCEDURE declaración

Declaración y asignación de variables

Controladores de excepciones

Instrucciones SQL dinámicas

Instrucciones de flujo de control

Otras declaraciones y elementos de lenguaje procedimental

Instrucciones SQL de varias líneas y con varias instrucciones

Otras instrucciones SQL

Garantías de coherencia y aislamiento de transacciones

Transacciones

Restauración

Límites de las bases de datos

Siguientes pasos

`SELECT` declaración

`INSERT` declaración

`UPDATE` declaración

`DELETE` y `TRUNCATE`

`MERGE` declaración

`CREATE TABLE` declaración

`DROP` declaración

`CREATE PROCEDURE` declaración