Esta página foi traduzida pela API Cloud Translation.

Guia de tradução de SQL do IBM Netezza

O armazenamento de dados do IBM Netezza foi concebido para funcionar com a sintaxe SQL específica do Netezza. O Netezza SQL baseia-se no Postgres 7.2. Os scripts SQL escritos para o Netezza não podem ser usados num armazém de dados do BigQuery sem alterações, porque os dialetos SQL variam.

Este documento detalha as semelhanças e as diferenças na sintaxe SQL entre o Netezza e o BigQuery nas seguintes áreas:

Tipos de dados
Elementos da linguagem SQL
Sintaxe de consulta
Linguagem de manipulação de dados (DML)
Linguagem de definição de dados (LDD)
Procedimentos armazenados
Funções

Também pode usar a tradução de SQL em lote para migrar os seus scripts SQL em massa ou a tradução de SQL interativa para traduzir consultas ad hoc. O IBM Netezza SQL/NZPLSQL é suportado por ambas as ferramentas em pré-visualização.

Tipos de dados

Netezza	BigQuery	Notes
`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 personalizados de dígitos ou escala (restrições) como o Netezza. O BigQuery tem 9 dígitos fixos após a vírgula, enquanto o Netezza permite uma configuração personalizada. No Netezza, a precisão `p` pode variar entre 1 e 38, e a escala `s` entre 0 e a precisão.
`FLOAT(p)`	`FLOAT64`
`REAL/FLOAT(6)`	`FLOAT64`
`DOUBLE PRECISION/FLOAT(14)`	`FLOAT64`
`CHAR/CHARACTER`	`STRING`	O tipo `STRING` no BigQuery tem um comprimento variável e não requer a definição manual de um comprimento máximo de carateres, ao contrário dos tipos `CHARACTER` e `VARCHAR` do Netezza. O valor predefinido de `n` em `CHAR(n)` é 1. O tamanho máximo da string de carateres é 64 000.
`VARCHAR`	`STRING`	O tipo `STRING` no BigQuery tem um comprimento variável e não requer a definição manual de um comprimento máximo de carateres, ao contrário dos tipos `CHARACTER` e `VARCHAR` do Netezza. O tamanho máximo da string de carateres é 64 000.
`NCHAR`	`STRING`	O tipo `STRING` no BigQuery é armazenado como Unicode com codificação UTF-8 de comprimento variável. O comprimento máximo é de 16 000 carateres.
`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 carateres.
`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-lhe transmitir uma diferença para UTC através da sintaxe `WITH TIME ZONE`. O tipo de dados `TIME` no BigQuery representa uma hora independente de qualquer data ou fuso horário.
`TIMESTAMP`	`DATETIME`	O tipo `TIMESTAMP` Netezza não inclui um fuso horário, tal como o tipo `DATETIME` BigQuery.
	`ARRAY`	Não existe nenhum tipo de dados de matriz no Netezza. Em alternativa, o tipo de matriz é armazenado num campo varchar.

Formatação do tipo de data/hora

Para mais informações sobre a formatação do tipo de data que o SQL do Netezza usa, consulte a documentação Padrões de data/hora do Netezza. Para mais informações sobre as funções de data/hora, consulte a documentação sobre as funções de data/hora do Netezza.

Quando converte elementos de formatação do tipo de data do Netezza para o GoogleSQL, tem de prestar especial atenção às diferenças de fuso horário entre TIMESTAMP e DATETIME, conforme resumido na tabela seguinte:

Netezza	BigQuery
`CURRENT_TIMESTAMP` `CURRENT_TIME` As informações `TIME` no Netezza podem ter informações de fuso horário diferentes, que são definidas através da 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 linhas de comando bq e na consolaGoogle Cloud é formatado com um separador `T` de acordo com a RFC 3339. No entanto, no Python e no Java JDBC, é usado um espaço como separador. Use a função `FORMAT_DATETIME` explícita para definir o formato de data corretamente. Caso contrário, é feita uma conversão explícita para uma string, por exemplo: `CAST(CURRENT_DATETIME() AS STRING)` Isto também devolve um separador de espaço.
`CURRENT_DATE`	`CURRENT_DATE`
`CURRENT_DATE-3`	O BigQuery não suporta operações de dados aritméticas. Em alternativa, use a função `DATE_ADD`.

`SELECT` declaração

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

Netezza BigQuery

Netezza	BigQuery
Uma declaração `SELECT` sem cláusula `FROM`	Suporta casos especiais, como os seguintes: `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 ao resultado de outras colunas definidas na mesma consulta. Tem de duplicar a lógica ou mover a lógica 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 declaração SELECT sem cláusula FROM

Suporta casos especiais, como os seguintes:

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 ao resultado de outras colunas definidas na mesma consulta. Tem de duplicar a lógica ou mover a lógica 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`	Inferior ou igual a
`exp < exp2`	`exp < exp2`	Inferior a
`exp <> exp2` `exp != exp2`	`exp <> exp2` `exp != exp2`	Não igual
`exp >= exp2`	`exp >= exp2`	Maior ou igual a
`exp > exp2`	`exp > exp2`	Superior a

Funções SQL integradas

Netezza	BigQuery	Descrição
`CURRENT_DATE`	`CURRENT_DATE`	Obtenha a data atual (ano, mês e dia).
`CURRENT_TIME`	`CURRENT_TIME`	Saiba qual é a hora atual com fração.
`CURRENT_TIMESTAMP`	`CURRENT_TIMESTAMP`	Obter a data e a hora do sistema atuais, até ao segundo completo mais próximo.
`NOW`	`CURRENT_TIMESTAMP`	Obtenha a data e a hora atuais do sistema, até ao 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)`	Devolve o número de dias desde o 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)`	Realizar adições em datas.
`DURATION_SUBTRACT(date, k)`	`DATE_SUB(date, INTERVAL k DAY)`	Subtrair datas.
`str1 \|\| str2`	`CONCAT(str1, str2)`	Concatenar strings.

Funções

Esta secçã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`	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`

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

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

Esta secção compara a sintaxe DML do Netezza e do BigQuery.

`INSERT` declaração

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 colunas na declaração `INSERT` só é válida se todas as colunas forem indicadas.
INSERT INTO table (...) VALUES (...); INSERT INTO table (...) VALUES (...);	INSERT INTO table VALUES (), (); O BigQuery impõe quotas de DML, que restringem o número de declarações de DML que pode executar diariamente. Para tirar o máximo partido da sua quota, considere as seguintes abordagens: Combine várias linhas numa única declaração `INSERT`, em vez de uma linha por declaração `INSERT`. Combine várias instruções DML (incluindo uma instrução `INSERT`) usando uma instrução `MERGE`. Use uma declaraçã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 colunas na declaração INSERT só é válida se todas as colunas forem indicadas.

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

INSERT INTO table VALUES (), ();

O BigQuery impõe quotas de DML, que restringem o número de declarações de DML que pode executar diariamente. Para tirar o máximo partido da sua quota, considere as seguintes abordagens:

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

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

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

Os scripts DML no BigQuery têm uma semântica de consistência ligeiramente diferente das declarações equivalentes no Netezza. Tenha também em atenção que o BigQuery não oferece restrições, exceto NOT NULL.

Para uma vista geral do isolamento de instantâneos e do processamento de sessões e transações, consulte o artigo Garantias de consistência e isolamento de transações.

`UPDATE` declaração

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

Netezza BigQuery

Netezza	BigQuery
UPDATE tbl SET tbl.col1=val1;	Não é suportado 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 é suportado 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 os UPDATE exemplos.

Devido às quotas de DML, recomendamos que use declarações MERGE maiores em vez de várias declaraçõ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 vista geral do isolamento de instantâneos e do processamento de sessões e transações, consulte o artigo Garantias de consistência e isolamento de transações.

`DELETE` e `TRUNCATE` extratos

As declarações DELETE e TRUNCATE são formas de remover linhas de uma tabela sem afetar o esquema ou os índices da tabela. A declaração TRUNCATE tem o mesmo efeito que a declaração DELETE, mas é muito mais rápida do que a declaração DELETE para tabelas grandes. A declaração TRUNCATE é suportada no Netezza, mas não no BigQuery. No entanto, pode usar declarações DELETE no Netezza e no BigQuery.

No BigQuery, a declaração DELETE tem de 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 são eliminadas.

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;	A substituição do conteúdo de uma tabela pelo resultado da consulta é o equivalente a uma transação. Pode fazê-lo com uma operação de `query` ou de cópia (`cp`). bq query \ --replace \ --destination_table \ tableA \ 'SELECT * \ FROM tableB \ WHERE ...' bq cp \ -f tableA tableB	Substituir o conteúdo de uma tabela pelos resultados de uma consulta.
DELETE FROM database.table	DELETE FROM table WHERE TRUE;	No Netezza, quando é executada uma declaração de eliminação, as linhas não são eliminadas fisicamente, mas apenas marcadas para eliminação. A execução dos comandos `GROOM TABLE` ou `nzreclaim` remove posteriormente as linhas marcadas para eliminação e reclama o espaço em disco correspondente.
`GROOM TABLE`		O Netezza usa o comando `GROOM TABLE` para reclamar espaço no disco removendo linhas marcadas para eliminação.

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

A substituição do conteúdo de uma tabela pelo resultado da consulta é o equivalente a uma transação. Pode fazê-lo com uma operação de query ou de cópia (cp).

bq query \

--replace \

--destination_table \

tableA \

'SELECT * \

FROM tableB \

WHERE ...'

bq cp \

-f tableA tableB

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

DELETE FROM database.table

DELETE FROM table WHERE TRUE;

No Netezza, quando é executada uma declaração de eliminação, as linhas não são eliminadas fisicamente, mas apenas marcadas para eliminação. A execução dos comandos GROOM TABLE ou nzreclaim remove posteriormente as linhas marcadas para eliminação e reclama o espaço em disco correspondente.

GROOM TABLE O Netezza usa o comando GROOM TABLE para reclamar espaço no disco removendo linhas marcadas para eliminação.

`MERGE` declaração

Uma declaração MERGE tem de corresponder, no máximo, a uma linha de origem para cada linha de destino. Os scripts DML no BigQuery têm uma semântica de consistência ligeiramente diferente das declarações equivalentes no Netezza. Para uma vista geral do isolamento de instantâneo e do processamento de sessões e transações, consulte Garantias de consistência e isolamento de transações. Para ver exemplos, consulte os exemplos do BigQuery MERGE e os exemplos do NetezzaMERGE.

Sintaxe DDL

Esta secção compara a sintaxe DDL do Netezza e do BigQuery.

`CREATE TABLE` declaração

Netezza	BigQuery	Descrição
`TEMP` `TEMPORARY`	Com o suporte de DDL do BigQuery, pode criar uma tabela a partir dos resultados de uma consulta e especificar a respetiva expiração no momento da criação. Por exemplo, para três dias: `CREATE TABLE` `'my-project.public_dump.vtemp'` `OPTIONS`( `expiration_timestamp=TIMESTAMP_ADD(CURRENT_TIMESTAMP(),` `INTERVAL 3 DAY))`	Criar tabelas temporárias para uma sessão.
`ZONE MAPS`	Não suportado.	Pesquisa rápida da condição de `WHERE`.
`DISTRIBUTE ON`	`PARTITION BY`	Partição. Esta não é uma tradução direta. `DISTRIBUTE ON` partilha dados entre nós, normalmente com uma chave única para uma distribuição uniforme, enquanto `PARTITION BY` reduz os dados em segmentos.
`ORGANIZE ON`	`CLUSTER BY`	O Netezza e o BigQuery suportam até quatro chaves para a agrupamento. As tabelas base agrupadas (CBT) do Netezza dão igual precedência a cada uma das colunas de agrupamento. O BigQuery dá precedência à primeira coluna na qual a tabela está agrupada, seguida da segunda coluna e assim sucessivamente.
`ROW SECURITY`	`Authorized View`	Segurança ao nível da linha.
`CONSTRAINT`	Não suportado	Verifique as restrições.

`DROP` declaração

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

Opções e atributos de colunas

Netezza	BigQuery	Descrição
`NULL` `NOT NULL`	`NULLABLE` `REQUIRED`	Especifique se a coluna pode conter valores `NULL`.
`REFERENCES`	Não suportado	Especifique a restrição da coluna.
`UNIQUE`	Não suportado	Cada valor na coluna tem de ser único.
`DEFAULT`	Não suportado	Valor predefinido para todos os valores na coluna.

Tabelas temporárias

O Netezza suporta TEMPORARY tabelas que existem durante a duração de uma sessão.

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

Crie um conjunto de dados com um tempo de vida curto (por exemplo, 12 horas).
Crie a tabela temporária no conjunto de dados com o prefixo do nome da tabela temp. Por exemplo, para criar uma tabela que expire dentro de 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 escrever a partir da tabela temporária.

Também pode remover duplicados de forma independente para encontrar erros nos sistemas a jusante.

Tenha em atenção que o BigQuery não suporta colunas DEFAULT e IDENTITY (sequências).

Declarações SQL processuais

O Netezza usa a linguagem de programação NZPLSQL para trabalhar com procedimentos armazenados. O NZPLSQL baseia-se na linguagem PL/pgSQL do Postgres. Esta seção descreve como converter declarações SQL processuais usadas em procedimentos armazenados, funções e acionadores do Netezza para o BigQuery.

`CREATE PROCEDURE` declaração

O Netezza e o BigQuery suportam a criação de procedimentos armazenados através da declaração CREATE PROCEDURE. Para mais informações, consulte o artigo Trabalhe com procedimentos armazenados de 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 um valor à variável.

Controladores de exceções

O Netezza suporta controladores de exceções que podem ser acionados para determinadas condições de erro. O BigQuery não suporta controladores de condições.

Netezza	BigQuery	Descrição
`EXCEPTION`	Não suportado	Declare o controlador de exceções SQL para erros gerais.

Declarações SQL dinâmicas

O Netezza suporta consultas SQL dinâmicas em procedimentos armazenados. O BigQuery não suporta declarações SQL dinâmicas.

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

Declarações de fluxo de controlo

Netezza	BigQuery	Descrição
`IF THEN ELSE STATEMENT` `IF` condition `THEN ...` `ELSE ...` `END IF;`	`IF` condition `THEN ...` `ELSE ...` `END IF;`	Executar condicionalmente.
Iterative Control `FOR var AS SELECT ...` `DO` stmts `END FOR;` `FOR var AS cur CURSOR` `FOR SELECT ...` `DO stmts END FOR;`	Não suportado	Iterar sobre uma coleção de linhas.
Controlo iterativo `LOOP stmts END LOOP;`	`LOOP` `sql_statement_list END LOOP;`	Bloco de declarações de ciclo.
`EXIT WHEN`	`BREAK`	Saia de um procedimento.
`WHILE condition LOOP`	`WHILE` condition `DO ...` `END WHILE`	Executar um ciclo de declarações até que uma condição while falhe.

Outras declarações e elementos de linguagem processual

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

Declarações SQL multilinhas e com várias declarações

O Netezza e o BigQuery suportam transações (sessões) e, por isso, suportam declarações separadas por pontos e vírgulas que são executadas em conjunto de forma consistente. Para mais informações, consulte o artigo Transações com vários extratos.

Outras declarações SQL

Netezza	BigQuery	Descrição
`GENERATE STATISTICS`		Gere estatísticas para todas as tabelas na base de dados atual.
`GENERATE STATISTICS ON table_name`		Gerar estatísticas para uma tabela específica.
`GENERATE STATISTICS ON table_name(col1,col4)`	Use funções estatísticas, como `MIN, MAX, AVG,`, etc., use a IU ou use a API Cloud Data Loss Prevention.	Gerar estatísticas para colunas específicas numa tabela.
`GENERATE STATISTICS ON table_name`	`APPROX_COUNT_DISTINCT(col)`	Mostrar o número de valores únicos para colunas.
`INSERT INTO table_name`	`INSERT INTO table_name`	Inserir uma linha.
`LOCK TABLE` `table_name FOR` `EXCLUSIVE;`	Não suportado	Bloquear linha.
`SET SESSION` `CHARACTERISTICS AS` `TRANSACTION ISOLATION LEVEL` …	O BigQuery usa sempre o isolamento de instantâneos. Para ver os detalhes, consulte as Garantias de consistência e isolamento de transações.	Defina o nível de isolamento da transação.
`BEGIN TRANSACTION` `END TRANSACTION` `COMMIT`	O BigQuery usa sempre o isolamento de instantâneos. Para ver os detalhes, consulte as Garantias de consistência e isolamento de transações.	Defina o limite da transação para pedidos com várias declarações.
`EXPLAIN` …	Não suportado. Funcionalidades semelhantes no plano de consulta e na cronologia	Mostrar plano de consulta para uma declaração `SELECT`.
Visualizações do utilizador metadados Metadados de visualizações do sistema	`SELECT` `* EXCEPT(is_typed)` `FROM` `mydataset.INFORMATION_SCHEMA.TABLES;` BigQuery Esquema de informações	Consultar objetos na base de dados

Garantias de consistência e isolamento de transações

O Netezza e o BigQuery são atómicos, ou seja, estão em conformidade com a norma ACID ao nível de cada mutação em várias linhas. Por exemplo, uma operação MERGE é completamente atómica, mesmo com vários valores inseridos.

Transações

O Netezza aceita sintaticamente todos os quatro modos de isolamento de transações ANSI SQL. No entanto, independentemente do modo especificado, é usado apenas o modo SERIALIZABLE, que oferece o nível de consistência mais elevado possível. Este modo também evita leituras sujas, não repetíveis e fantasma entre transações simultâneas. O Netezza não usa a sincronização convencional para aplicar a consistência. Em alternativa, usa a verificação de dependência de serialização, uma forma de controlo de simultaneidade otimista para reverter automaticamente a transação mais recente quando duas transações tentam modificar os mesmos dados.

O BigQuery também suporta transações. O BigQuery ajuda a garantir o controlo de simultaneidade otimista (a primeira confirmação tem prioridade) com o isolamento de instantâneos, em que uma consulta lê os últimos dados confirmados antes de começar. Esta abordagem garante o mesmo nível de consistência por linha, por mutação e entre linhas na mesma declaração DML, mas evita bloqueios. No caso de várias atualizações de DML na mesma tabela, o BigQuery muda para o controlo de concorrência pessimista. Os trabalhos de carregamento podem ser executados de forma totalmente independente e anexados a tabelas.

Reversão

O Netezza suporta a declaração ROLLBACK para anular a transação atual e reverter todas as alterações feitas na transação.

No BigQuery, pode usar a declaração ROLLBACK TRANSACTION.

Limites da base de dados

Limite	Netezza	BigQuery
Tabelas por base de dados	32 000	Sem restrições
Colunas por tabela	1600	10000
Tamanho máximo da linha	64 KB	100 MB
Comprimento do nome da coluna e da tabela	128 bytes	16 384 carateres Unicode
Linhas por tabela	Ilimitado	Ilimitado
Comprimento máximo do pedido SQL		1 MB (comprimento máximo da consulta SQL padrão não resolvido). 12 MB (comprimento máximo da consulta SQL antiga e padrão resolvido). Streaming: 10 MB (limite de tamanho do pedido HTTP) 10 000 (máximo de linhas por pedido)
Tamanho máximo do pedido e da resposta		10 MB (pedido) e 10 GB (resposta) ou praticamente ilimitado se usar a paginação ou a API Cloud Storage.
Número máximo de sessões em simultâneo	63 transações de leitura/escrita simultâneas. 2000 ligações simultâneas ao servidor.	100 consultas simultâneas (podem ser aumentadas com a reserva de slots), 300 pedidos de API simultâneos por utilizador.

O que se segue?

Receba instruções passo a passo para migrar do IBM Netezza para o BigQuery.

Guia de tradução de SQL do IBM Netezza

Tipos de dados

Formatação do tipo de data/hora

SELECT declaração

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

INSERT declaração

UPDATE declaração

DELETE e TRUNCATE extratos

MERGE declaração

Sintaxe DDL

CREATE TABLE declaração

DROP declaração

Opções e atributos de colunas

Tabelas temporárias

Declarações SQL processuais

CREATE PROCEDURE declaração

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

Controladores de exceções

Declarações SQL dinâmicas

Declarações de fluxo de controlo

Outras declarações e elementos de linguagem processual

Declarações SQL multilinhas e com várias declarações

Outras declarações SQL

Garantias de consistência e isolamento de transações

Transações

Reversão

Limites da base de dados

O que se segue?

`SELECT` declaração

`INSERT` declaração

`UPDATE` declaração

`DELETE` e `TRUNCATE` extratos

`MERGE` declaração

`CREATE TABLE` declaração

`DROP` declaração

`CREATE PROCEDURE` declaração