Guia de tradução do IBM Netezza SQL

O armazenamento em data warehouse do IBM Netezza foi projetado para funcionar com a sintaxe SQL específica do Netezza. que tem como base o Postgres 7.2. Os scripts SQL criados para o Netezza não podem ser usados em um data warehouse do BigQuery sem alterações porque os dialetos de SQL variam.

Neste documento, detalhamos as semelhanças e diferenças entre a sintaxe SQL do Netezza e do BigQuery nas seguintes áreas:

Tipos de dados
Elementos da linguagem SQL
Sintaxe das consultas
Linguagem de Manipulação de Dados (DML)
Linguagem de definição de dados (DDL)
Procedimentos armazenados
Funções

Também é possível usar tradução de SQL em lote para migrar os scripts SQL em massa ou a tradução de SQL interativo para traduzir consultas ad hoc. O IBM Netezza SQL/NZPLSQL é compatível com as duas ferramentas em pré-lançamento.

Tipos de dados

Netezza	BigQuery	Observações
`INTEGER/INT/INT4`	`INT64`
`SMALLINT/INT2`	`INT64`
`BYTEINT/INT1`	`INT64`
`BIGINT/INT8`	`INT64`
`DECIMAL`	`NUMERIC`	O tipo de dados `DECIMAL` no Netezza é um alias para o tipo de dados `NUMERIC`.
`NUMERIC`	`NUMERIC` `INT64`
`NUMERIC(p,s)`	`NUMERIC`	O tipo `NUMERIC` no BigQuery não aplica limites de dígitos personalizados ou de escala (restrições), ao contrário do Netezza. O BigQuery fixou 9 dígitos após o decimal, enquanto o Netezza permite uma configuração personalizada. No Netezza, a precisão `p` pode variar de 1 a 38 e escalonar `s` de 0 para a precisão.
`FLOAT(p)`	`FLOAT64`
`REAL/FLOAT(6)`	`FLOAT64`
`DOUBLE PRECISION/FLOAT(14)`	`FLOAT64`
`CHAR/CHARACTER`	`STRING`	O tipo `STRING` no BigQuery tem tamanho variável e não requer a configuração manual de um tamanho máximo de caracteres, ao contrário dos tipos `CHARACTER` e do `VARCHAR` do Netezza. O valor padrão de `n` em `CHAR(n)` é 1. O tamanho máximo da string de caracteres é 64.000.
`VARCHAR`	`STRING`	O tipo `STRING` no BigQuery tem tamanho variável e não requer a configuração manual de um tamanho máximo de caracteres, ao contrário dos tipos `CHARACTER` e do `VARCHAR` do Netezza. O tamanho máximo da string de caracteres é 64.000.
`NCHAR`	`STRING`	O tipo `STRING` no BigQuery é armazenado como Unicode codificado em UTF-8 de tamanho variável. O comprimento máximo é de 16.000 caracteres.
`NVARCHAR`	`STRING`	O tipo `STRING` no BigQuery é armazenado como Unicode codificado em UTF-8 de comprimento variável. O comprimento máximo é de 16.000 caracteres.
`VARBINARY`	`BYTES`
`ST_GEOMETRY`	`GEOGRAPHY`
`BOOLEAN/BOOL`	`BOOL`	O tipo `BOOL` no BigQuery só pode aceitar `TRUE/FALSE`, ao contrário do tipo `BOOL` no Netezza, que pode aceitar uma variedade de valores como `0/1`, `yes/no`, `true/false,` e `on/off`.
`DATE`	`DATE`
`TIME`	`TIME`
`TIMETZ/TIME WITH TIME ZONE`	`TIME`	O Netezza armazena o tipo de dados `TIME` em UTC e permite que você transmita um deslocamento de UTC usando a sintaxe `WITH TIME ZONE`. O tipo de dados `TIME` no BigQuery representa um horário independente de qualquer data ou fuso horário.
`TIMESTAMP`	`DATETIME`	O tipo `TIMESTAMP` do Netezza não inclui um fuso horário, igual ao tipo `DATETIME` do BigQuery.
	`ARRAY`	Não há um tipo de dado de matriz no Netezza. Em vez disso, o tipo de matriz é armazenado em um campo varchar (em inglês).

Formatação de carimbo de data/hora e tipo de data

Para mais informações sobre a formatação do tipo de data que o Netezza SQL usa, consulte a documentação sobre padrões de modelo de data e hora do Netezza (em inglês). Para ver mais informações sobre as funções de data e hora, consulte a documentação Funções de data/hora do Netezza (em inglês).

Ao converter elementos de formatação de tipo de data do Netezza em GoogleSQL, preste atenção às diferenças de fuso horário entre TIMESTAMP e DATETIME, conforme resumido na tabela a seguir:

Netezza	BigQuery
`CURRENT_TIMESTAMP` `CURRENT_TIME` `TIME` As informações no Netezza podem ter informações de fuso horário diferentes, que são definidas usando a sintaxe `WITH TIME ZONE`.	Se possível, use a função `CURRENT_TIMESTAMP`, que está formatada corretamente. No entanto, o formato de saída nem sempre mostra o fuso horário UTC (internamente, o BigQuery não tem um fuso horário). O objeto `DATETIME` na ferramenta de linha de comando bq e no Console do Google Cloud é formatado usando um separador `T` de acordo com o RFC 3.339. No entanto, em Python e Java JDBC, um espaço é usado como separador. Use a função explícita `FORMAT_DATETIME` para definir o formato de data corretamente. Caso contrário, uma transmissão explícita será feita para uma string, por exemplo: `CAST(CURRENT_DATETIME() AS STRING)` Isso também retorna um separador de espaço.
`CURRENT_DATE`	`CURRENT_DATE`
`CURRENT_DATE-3`	O BigQuery não é compatível com operações de dados aritméticos. Em vez disso, use a função `DATE_ADD`.

Instrução `SELECT`

Geralmente, a instrução SELECT do Netezza é compatível com o BigQuery. A tabela a seguir contém uma lista de exceções:

Netezza BigQuery

Netezza	BigQuery
Uma instrução `SELECT` sem cláusula `FROM`	Oferece suporte a casos especiais como estes: `SELECT 1 UNION ALL SELECT 2;`
SELECT (subquery) AS flag, CASE WHEN flag = 1 THEN ...	No BigQuery, as colunas não podem fazer referência à saída de outras colunas definidas na mesma consulta. É necessário duplicar a lógica ou movê-la para uma consulta aninhada. Opção 1 SELECT (subquery) AS flag, CASE WHEN (subquery) = 1 THEN ... Opção 2 SELECT q.*, CASE WHEN flag = 1 THEN ... FROM ( SELECT (subquery) AS flag, ... ) AS q

Uma instrução SELECT sem cláusula FROM

Oferece suporte a casos especiais como estes:

SELECT 1 UNION ALL SELECT 2;


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

No BigQuery, as colunas não podem fazer referência à saída de outras colunas definidas na mesma consulta. É necessário duplicar a lógica ou movê-la para uma consulta aninhada.

Opção 1


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

Opção 2


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

Operadores de comparação

Netezza	BigQuery	Descrição
`exp = exp2`	`exp = exp2`	Igual
`exp <= exp2`	`exp <= exp2`	Menor que ou igual a
`exp < exp2`	`exp < exp2`	Menos de
`exp <> exp2` `exp != exp2`	`exp <> exp2` `exp != exp2`	Diferente
`exp >= exp2`	`exp >= exp2`	Maior que ou igual a
`exp > exp2`	`exp > exp2`	Maior que

Funções SQL integradas

Netezza	BigQuery	Descrição
`CURRENT_DATE`	`CURRENT_DATE`	Veja a data atual (ano, mês e dia).
`CURRENT_TIME`	`CURRENT_TIME`	Veja o horário atual com fração.
`CURRENT_TIMESTAMP`	`CURRENT_TIMESTAMP`	Veja a data e a hora atuais do sistema, com o segundo completo mais próximo.
`NOW`	`CURRENT_TIMESTAMP`	Veja a data e a hora atuais do sistema, com o segundo completo mais próximo.
`COALESCE(exp, 0)`	`COALESCE(exp, 0)`	Substitua `NULL` por zero.
`NVL(exp, 0)`	`IFNULL(exp, 0)`	Substitua `NULL` por zero.
`EXTRACT(DOY FROM timestamp_expression)`	`EXTRACT(DAYOFYEAR FROM timestamp_expression)`	Retorne o número de dias a partir do início do ano.
`ADD_MONTHS(date_expr, num_expr)`	`DATE_ADD(date, INTERVAL k MONTH)`	Adicionar meses a uma data.
`DURATION_ADD(date, k)`	`DATE_ADD(date, INTERVAL k DAY)`	Faça a adição em datas.
`DURATION_SUBTRACT(date, k)`	`DATE_SUB(date, INTERVAL k DAY)`	Faça a subtração nas datas.
`str1 \|\| str2`	`CONCAT(str1, str2)`	Concatenar strings.

Funções

Esta seção compara as funções do Netezza e do BigQuery.

Funções de agregação

Netezza	BigQuery
	`ANY_VALUE`
	`APPROX_COUNT_DISTINCT`
	`APPROX_QUANTILES`
	`APPROX_TOP_COUNT`
	`APPROX_TOP_SUM`
`AVG`	`AVG`
`intNand`	`BIT_AND`
`intNnot`	Lógica binária não operadora: `~`
`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`

Funções 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`	Lógica binária não operadora: `~`
`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`

Funções de data e 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`

Funções 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`

Funções 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)`

Sintaxe DML

Nesta seção, comparamos a sintaxe DML do Netezza e do BigQuery.

Instrução `INSERT`

Netezza BigQuery

Netezza	BigQuery
INSERT INTO table VALUES (...);	INSERT INTO table (...) VALUES (...); O Netezza oferece uma palavra-chave `DEFAULT` e outras restrições para colunas. No BigQuery, a omissão de nomes de coluna na instrução `INSERT` é válida somente se todas as colunas forem fornecidas.
INSERT INTO table (...) VALUES (...); INSERT INTO table (...) VALUES (...);	INSERT INTO table VALUES (), (); O BigQuery impõe cotas DML, que restringem o número de instruções DML que podem ser executadas diariamente. Para fazer o melhor uso da sua cota, considere as seguintes abordagens: Combine várias linhas em uma única instrução `INSERT`, em vez de uma linha por operação `INSERT`. Combine várias instruções DML (incluindo uma instrução `INSERT`) usando uma instrução `MERGE`; Use uma instrução `CREATE TABLE ... AS SELECT` para criar e preencher novas tabelas.


INSERT INTO table VALUES (...);


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

O Netezza oferece uma palavra-chave DEFAULT e outras restrições para colunas. No BigQuery, a omissão de nomes de coluna na instrução INSERT é válida somente se todas as colunas forem fornecidas.


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


INSERT INTO table VALUES (), ();

O BigQuery impõe cotas DML, que restringem o número de instruções DML que podem ser executadas diariamente. Para fazer o melhor uso da sua cota, considere as seguintes abordagens:

Combine várias linhas em uma única instrução INSERT, em vez de uma linha por operação INSERT.

Combine várias instruções DML (incluindo uma instrução INSERT) usando uma instrução MERGE;

Use uma instrução CREATE TABLE ... AS SELECT para criar e preencher novas tabelas.

Os scripts DML no BigQuery têm semânticas de consistência ligeiramente diferentes das instruções equivalentes no Netezza. Além disso, o BigQuery não oferece restrições além de NOT NULL.

Para uma visão geral do isolamento de snapshot e do processamento de sessões e transações, consulte Garantias de consistência e isolamento da transação.

Instrução `UPDATE`

No Netezza, a cláusula WHERE é opcional, mas no BigQuery ela é necessária.

Netezza BigQuery

Netezza	BigQuery
UPDATE tbl SET tbl.col1=val1;	Não compatível sem a cláusula `WHERE`. Use uma cláusula `WHERE true` para atualizar todas as linhas.
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;

Não compatível sem a cláusula WHERE. Use uma cláusula WHERE true para atualizar todas as linhas.


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 exemplos, consulte exemplos de UPDATE.

Devido às cotas de DML, recomendamos que você use instruções MERGE maiores, em vez de várias instruções UPDATE e INSERT únicas. Os scripts DML no BigQuery têm uma semântica de consistência ligeiramente diferente das declarações equivalentes no Netezza. Para uma visão geral do isolamento de snapshot e do processamento de sessões e transações, consulte Garantias de consistência e isolamento de transações.

Declarações `DELETE` e `TRUNCATE`.

As instruções DELETE e TRUNCATE são maneiras de remover linhas de uma tabela sem afetar seu esquema ou índices. A instrução TRUNCATE tem o mesmo efeito que a instrução DELETE, mas é muito mais rápida do que a instrução DELETE para tabelas grandes. A instrução TRUNCATE é aceita no Netezza, mas não no BigQuery. Porém, é possível usar instruções DELETE no Netezza e no BigQuery.

No BigQuery, a instrução DELETE precisa ter uma cláusula WHERE. No Netezza, a cláusula WHERE é opcional. Se a cláusula WHERE não for especificada, todas as linhas na tabela Netezza serão excluídas.

Netezza BigQuery Descrição

Netezza	BigQuery	Descrição
BEGIN; LOCK TABLE A IN EXCLUSIVE MODE; DELETE FROM A; INSERT INTO A SELECT * FROM B; COMMIT;	Substituir o conteúdo de uma tabela pela saída da consulta é equivalente a uma transação. É possível fazer isso com uma operação `query` ou cópia (`cp`). bq query \ --replace \ --destination_table \ tableA \ 'SELECT * \ FROM tableB \ WHERE ...' bq cp \ -f tableA tableB	Substitua o conteúdo de uma tabela pelos resultados de uma consulta.
DELETE FROM database.table	DELETE FROM table WHERE TRUE;	No Netezza, quando uma instrução de exclusão é executada, as linhas não são excluídas fisicamente, mas apenas marcadas para exclusão. A execução dos comandos `GROOM TABLE` ou `nzreclaim` posteriormente remove as linhas marcadas para exclusão e recupera o espaço em disco correspondente.
`GROOM TABLE`		O Netezza usa o comando `GROOM TABLE` para recuperar espaço em disco removendo linhas marcadas para exclusão.


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

Substituir o conteúdo de uma tabela pela saída da consulta é equivalente a uma transação. É possível fazer isso com uma operação query ou cópia (cp).


bq query \

--replace \

--destination_table \

tableA \

'SELECT * \

FROM tableB \

WHERE ...'


bq cp \

-f tableA tableB

Substitua o conteúdo de uma tabela pelos resultados de uma consulta.


DELETE FROM database.table


DELETE FROM table WHERE TRUE;

No Netezza, quando uma instrução de exclusão é executada, as linhas não são excluídas fisicamente, mas apenas marcadas para exclusão. A execução dos comandos GROOM TABLE ou nzreclaim posteriormente remove as linhas marcadas para exclusão e recupera o espaço em disco correspondente.

GROOM TABLE O Netezza usa o comando GROOM TABLE para recuperar espaço em disco removendo linhas marcadas para exclusão.

Instrução `MERGE`

Uma instrução MERGE precisa corresponder a, no máximo, uma linha de origem para cada linha de destino. Os scripts DML no BigQuery têm semânticas de consistência ligeiramente diferentes das instruções equivalentes no Netezza. Para uma visão geral do isolamento de snapshot e do processamento de sessões e transações, consulte Garantias de consistência e isolamento de transações. Para ver exemplos, consulte Exemplos de MERGE do BigQuery e Exemplos de MERGE do Netezza.

Sintaxe DDL

Nesta seção, comparamos a sintaxe DDL do Netezza e do BigQuery.

Instrução `CREATE TABLE`

Netezza	BigQuery	Descrição
`TEMP` `TEMPORARY`	Com o suporte a DDL do BigQuery, é possível criar uma tabela usando os resultados de uma consulta e especificar a expiração dela no momento da criação. Por exemplo, por três dias: `CREATE TABLE` `'fh-bigquery.public_dump.vtemp'` `OPTIONS`( `expiration_timestamp=TIMESTAMP_ADD(CURRENT_TIMESTAMP(),` `INTERVAL 3 DAY))`	Criar tabelas temporariamente para uma sessão.
`ZONE MAPS`	Incompatível.	Pesquisa rápida pela condição `WHERE`.
`DISTRIBUTE ON`	`PARTITION BY`	Particionamento. Esta não é uma tradução direta. O `DISTRIBUTE ON` compartilha dados entre nós, geralmente com uma chave exclusiva para distribuição uniforme, enquanto `PARTITION BY` remove os dados em segmentos.
`ORGANIZE ON`	`CLUSTER BY`	O Netezza e o BigQuery oferecem suporte a até quatro chaves para clustering. As tabelas com base em cluster (CBT, na sigla em inglês) do Netezza têm precedência em relação a cada uma das colunas em clustering. O BigQuery dá precedência à primeira coluna em que a tabela está em cluster, seguida pela segunda coluna e assim por diante.
`ROW SECURITY`	`Authorized View`	Segurança no nível da linha.
`CONSTRAINT`	Sem suporte	Verificar restrições.

Instrução `DROP`

Netezza	BigQuery	Descrição
`DROP TABLE`	`DROP TABLE`
`DROP DATABASE`	`DROP DATABASE`
`DROP VIEW`	`DROP VIEW`

Atributos e opções de coluna

Netezza	BigQuery	Descrição
`NULL` `NOT NULL`	`NULLABLE` `REQUIRED`	Especifique se a coluna pode conter valores `NULL`.
`REFERENCES`	Sem suporte	Especifique a restrição da coluna.
`UNIQUE`	Sem suporte	Cada valor na coluna precisa ser exclusivo.
`DEFAULT`	Sem suporte	Valor padrão de todos os valores na coluna.

Tabelas temporárias

O Netezza é compatível com tabelas TEMPORARY que existem durante a sessão.

Para criar uma tabela temporária no BigQuery, faça o seguinte:

Crie um conjunto de dados com uma vida curta (por exemplo, 12 horas).
Crie a tabela temporária no conjunto de dados com um prefixo de nome de tabela de temp. Por exemplo, para criar uma tabela que expira em uma hora, faça o seguinte:
```
CREATE TABLE temp.name (col1, col2, ...)
OPTIONS(expiration_timestamp = TIMESTAMP_ADD(CURRENT_TIMESTAMP(),
INTERVAL 1 HOUR));
```
Comece a ler e gravar na tabela temporária.

Também é possível remover duplicatas de forma independente para encontrar erros em sistemas downstream.

O BigQuery não é compatível com colunas DEFAULT e IDENTITY (sequências).

Instruções SQL procedurais

O Netezza usa a linguagem de script NZPLSQL para trabalhar com procedimentos armazenados. O NZPLSQL é baseado na linguagem PL/pgSQL do Postgres. Nesta seção, descrevemos como converter instruções SQL processuais usadas em procedimentos, funções e gatilhos armazenados do Netezza para o BigQuery.

Instrução `CREATE PROCEDURE`

O Netezza e o BigQuery aceitam a criação de procedimentos armazenados usando a instrução CREATE PROCEDURE. Para mais informações, consulte Trabalhar com procedimentos armazenados SQL.

Declaração e atribuição de variáveis

Netezza	BigQuery	Descrição
`DECLARE var datatype(len) [DEFAULT value];`	`DECLARE`	Declare a variável.
`SET var = value;`	`SET`	Atribua valor à variável.

Gerenciadores de exceções

O Netezza é compatível com gerenciadores de exceção que podem ser acionados para determinadas condições de erro. O BigQuery não oferece suporte a gerenciadores de condições.

Netezza	BigQuery	Descrição
`EXCEPTION`	Sem suporte	Declare o gerenciador de exceção SQL para erros gerais.

Instruções SQL dinâmicas

O Netezza é compatível com consultas SQL dinâmicas dentro de procedimentos armazenados. O BigQuery não oferece suporte para instruções SQL dinâmicas.

Netezza	BigQuery	Descrição
`EXECUTE IMMEDIATE` `sql_str;`	`EXECUTE IMMEDIATE` `sql_str;`	Executar SQL dinâmico.

Instruções de fluxo de controle

Netezza	BigQuery	Descrição
`IF THEN ELSE STATEMENT` `IF` condição `THEN ...` `ELSE ...` `END IF;`	`IF` condição `THEN ...` `ELSE ...` `END IF;`	Execute condicionalmente.
Controle iterativo `FOR var AS SELECT ...` `DO` stmts `END FOR;` `FOR var AS cur CURSOR` `FOR SELECT ...` `DO stmts END FOR;`	Sem suporte	Iterar em um conjunto de linhas.
Controle iterativo `LOOP stmts END LOOP;`	`LOOP` `sql_statement_list END LOOP;`	Repetição de bloco de instruções.
`EXIT WHEN`	`BREAK`	Sair de um procedimento.
`WHILE condition LOOP`	`WHILE` condição `DO ...` `END WHILE`	Executar um loop de instruções até que uma condição de tempo falhe.

Outras declarações e elementos de linguagem processual

Netezza	BigQuery	Descrição
`CALL` `proc(param,...)`	Sem suporte	Executar um procedimento.
`EXEC` `proc(param,...)`	Sem suporte	Executar um procedimento.
`EXECUTE` `proc(param,...)`	Sem suporte	Executar um procedimento.

Instruções SQL com várias instruções e linhas

O Netezza e o BigQuery aceitam transações (sessões) e, portanto, são compatíveis com instruções separadas por ponto e vírgula que são executados consistentemente em conjunto. Para mais informações, consulte Transações de várias instruções.

Outras instruções SQL

Netezza	BigQuery	Descrição
`GENERATE STATISTICS`		Gera estatísticas para todas as tabelas no banco de dados atual.
`GENERATE STATISTICS ON table_name`		Gera estatísticas para uma tabela específica.
`GENERATE STATISTICS ON table_name(col1,col4)`	Usa funções estatísticas, como `MIN, MAX, AVG,`, entre outras, a IU ou a API Cloud Data Loss Prevention.	Gera estatísticas para colunas específicas em uma tabela.
`GENERATE STATISTICS ON table_name`	`APPROX_COUNT_DISTINCT(col)`	Mostra o número de valores exclusivos para colunas.
`INSERT INTO table_name`	`INSERT INTO table_name`	Insere uma linha.
`LOCK TABLE` `table_name FOR` `EXCLUSIVE;`	Sem suporte	Linha de bloqueio.
`SET SESSION` `CHARACTERISTICS AS` `TRANSACTION ISOLATION LEVEL` ...	O BigQuery sempre usa o isolamento de snapshot. Para detalhes, consulte Garantias de consistência e isolamento de transações.	Define o nível de isolamento da transação.
`BEGIN TRANSACTION` `END TRANSACTION` `COMMIT`	O BigQuery sempre usa o isolamento de snapshot. Para detalhes, consulte Garantias de consistência e isolamento de transações.	Define o limite de transação para solicitações de várias instruções.
`EXPLAIN` ...	Incompatível. Recursos semelhantes no plano de consulta e no cronograma	Mostra o plano de consulta de uma instrução `SELECT`.
Metadados de Visualizações de usuários Metadados de Visualizações do sistema	`SELECT` `* EXCEPT(is_typed)` `FROM` `mydataset.INFORMATION_SCHEMA.TABLES;` Esquema de informação do BigQuery	Consulta objetos no banco de dados

Garantias de consistência e isolamento da transação

O Netezza e o BigQuery são atômicos, ou seja, estão em conformidade com ACID (em inglês) em um nível por mutação em muitas linhas. Por exemplo, uma operação MERGE é completamente atômica, mesmo com vários valores inseridos.

Transações

O Netezza aceita a sintaxe de todos os quatro modos de isolamento de transações de SQL ANSI. Porém, independentemente do modo especificado, apenas o modo SERIALIZABLE será usado, o que proporciona o maior nível de consistência possível. Esse modo também evita leituras sujas, não reproduzíveis e fantasmas entre transações simultâneas. O Netezza não usa bloqueios convencionais para aplicar a consistência. Em vez disso, ele usa a verificação de dependência de serialização, uma forma de controle de simultaneidade otimista para reverter automaticamente a transação mais recente quando duas transações tentam modificar os mesmos dados.

O BigQuery também tem suporte a transações. O BigQuery ajuda a garantir o controle de simultaneidade otimista (o primeiro a confirmar tem prioridade) com o isolamento de snapshot, em que uma consulta lê os últimos dados confirmados antes do início da consulta. Essa abordagem garante o mesmo nível de consistência por linha, por mutação e em todas as linhas da mesma instrução DML, evitando impasses. No caso de várias atualizações de DML na mesma tabela, o BigQuery alterna para controle de simultaneidade pessimista. Os jobs de carregamento podem ser executados de forma totalmente independente e anexados às tabelas.

Reverter

O Netezza oferece suporte à instrução ROLLBACK para cancelar a transação atual e reverter todas as alterações feitas na transação.

No BigQuery, é possível usar a instrução ROLLBACK TRANSACTION.

Limites de bancos de dados

Limite	Netezza	BigQuery
Tabelas por banco de dados	32.000	Irrestrito
Colunas por tabela	1.600	10000
Tamanho máximo da linha	64 KB	100 MB
Tamanho do nome da coluna e da tabela	128 bytes	16.384 caracteres Unicode
Linhas por tabela	Ilimitado	Ilimitado
Tamanho máximo da solicitação SQL		1 MB (tamanho máximo de consulta SQL padrão não resolvida). 12 MB (tamanho máximo da consulta SQL legada e padrão resolvida). Streaming: 10 MB (limite de tamanho da solicitação HTTP) 10.000 (máximo de linhas por solicitação)
Tamanho máximo da solicitação e da resposta		10 MB (solicitação) e 10 GB (resposta) ou virtualmente ilimitados se usar paginação ou a API Cloud Storage.
Número máximo de sessões simultâneas	63 transações de leitura/gravação simultâneas. 2.000 conexões simultâneas com o servidor.	100 consultas simultâneas (podem ser geradas com uma reserva de slot), 300 solicitações de API simultâneas por usuário.

A seguir

Veja instruções passo a passo para Migrar do IBM Netezza para o BigQuery.

Guia de tradução do IBM Netezza SQL

Tipos de dados

Formatação de carimbo de data/hora e tipo de data

Instrução SELECT

Operadores de comparação

Funções SQL integradas

Funções

Funções de agregação

Funções analíticas

Funções de data e hora

Funções de string

Funções matemáticas

Sintaxe DML

Instrução INSERT

Instrução UPDATE

Declarações DELETE e TRUNCATE.

Instrução MERGE

Sintaxe DDL

Instrução CREATE TABLE

Instrução DROP

Atributos e opções de coluna

Tabelas temporárias

Instruções SQL procedurais

Instrução CREATE PROCEDURE

Declaração e atribuição de variáveis

Gerenciadores de exceções

Instruções SQL dinâmicas

Instruções de fluxo de controle

Outras declarações e elementos de linguagem processual

Instruções SQL com várias instruções e linhas

Outras instruções SQL

Garantias de consistência e isolamento da transação

Transações

Reverter

Limites de bancos de dados

A seguir

Instrução `SELECT`

Instrução `INSERT`

Instrução `UPDATE`

Declarações `DELETE` e `TRUNCATE`.

Instrução `MERGE`

Instrução `CREATE TABLE`

Instrução `DROP`

Instrução `CREATE PROCEDURE`