Guia de tradução do Oracle SQL

Este documento detalha as semelhanças e diferenças de sintaxe SQL entre a Oracle e o BigQuery para ajudar você a planejar sua migração. Use a tradução SQL em lote para migrar os scripts SQL em massa ou a tradução de SQL interativo para traduzir consultas ad-hoc.

Tipos de dados

Esta seção mostra os equivalentes entre os tipos de dados na Oracle e no BigQuery.

Oracle	BigQuery	Observações
`VARCHAR2`	`STRING`
`NVARCHAR2`	`STRING`
`CHAR`	`STRING`
`NCHAR`	`STRING`
`CLOB`	`STRING`
`NCLOB`	`STRING`
`INTEGER`	`INT64`
`SHORTINTEGER`	`INT64`
`LONGINTEGER`	`INT64`
`NUMBER`	`NUMERIC`	O BigQuery não permite que o usuário especifique valores personalizados para precisão ou escala. Como resultado, uma coluna no Oracle pode ser definida para que tenha uma escala maior do que o BigQuery suporta. Além disso, antes de armazenar um número decimal, a Oracle arredonda se esse número tiver mais dígitos depois do ponto decimal que o especificado para a coluna correspondente. No BigQuery, esse recurso pode ser implementado usando a função `ROUND()`.
`NUMBER(*, x)`	`NUMERIC`	O BigQuery não permite que o usuário especifique valores personalizados para precisão ou escala. Como resultado, uma coluna no Oracle pode ser definida para que tenha uma escala maior do que o BigQuery suporta. Além disso, antes de armazenar um número decimal, a Oracle arredonda se esse número tiver mais dígitos depois do ponto decimal que o especificado para a coluna correspondente. No BigQuery, esse recurso pode ser implementado usando a função `ROUND()`.
`NUMBER(x, -y)`	`INT64`	Se um usuário tentar armazenar um número decimal, a Oracle arredonda para um número inteiro. Para o BigQuery, uma tentativa de armazenar um número decimal em uma coluna definida como `INT64` resulta em erro. Nesse caso, a função `ROUND()` precisa ser aplicada. Os tipos de dados `INT64` do BigQuery permitem até 18 dígitos de precisão. Se um campo numérico tiver mais de 18 dígitos, será necessário usar o tipo de dados `FLOAT64` no BigQuery.
`NUMBER(x)`	`INT64`	Se um usuário tentar armazenar um número decimal, a Oracle arredonda para um número inteiro. Para o BigQuery, uma tentativa de armazenar um número decimal em uma coluna definida como `INT64` resulta em erro. Nesse caso, a função `ROUND()` precisa ser aplicada. Os tipos de dados `INT64` do BigQuery permitem até 18 dígitos de precisão. Se um campo numérico tiver mais de 18 dígitos, será necessário usar o tipo de dados `FLOAT64` no BigQuery.
`FLOAT`	`FLOAT64`/`NUMERIC`	`FLOAT` é um tipo de dados exato e `NUMBER` é um subtipo na Oracle. No BigQuery, `FLOAT64` é um tipo de dado aproximado. `NUMERIC` pode ser uma correspondência melhor para o tipo `FLOAT` no BigQuery.
`BINARY_DOUBLE`	`FLOAT64`/`NUMERIC`	`FLOAT` é um tipo de dados exato e `NUMBER` é um subtipo na Oracle. No BigQuery, `FLOAT64` é um tipo de dado aproximado. `NUMERIC` pode ser uma correspondência melhor para o tipo `FLOAT` no BigQuery.
`BINARY_FLOAT`	`FLOAT64`/`NUMERIC`	`FLOAT` é um tipo de dados exato e `NUMBER` é um subtipo na Oracle. No BigQuery, `FLOAT64` é um tipo de dado aproximado. `NUMERIC` pode ser uma correspondência melhor para o tipo `FLOAT` no BigQuery.
`LONG`	`BYTES`	O tipo de dados `LONG` é usado em versões anteriores e não é sugerido em novas versões da Oracle Database. O tipo de dados `BYTES` no BigQuery poderá ser usado se for necessário armazenar dados `LONG` no BigQuery. Uma abordagem melhor seria colocar objetos binários no Cloud Storage e manter referências no BigQuery.
`BLOB`	`BYTES`	O tipo de dados `BYTES` pode ser usado para armazenar dados binários de comprimento variável. Se esse campo não for consultado e não for usado em análise, a melhor opção é armazenar dados binários no Cloud Storage.
`BFILE`	`STRING`	Os arquivos binários podem ser armazenados no Cloud Storage, e o tipo de dados `STRING` pode ser usado para referenciar arquivos em uma tabela do BigQuery.
`DATE`	`DATETIME`
`TIMESTAMP`	`TIMESTAMP`	O BigQuery oferece suporte à precisão de microssegundos (10^-6) em comparação com a Oracle, que é compatível com a precisão variando de 0 a 9. O BigQuery oferece suporte para o nome de região de fuso horário de um banco de dados TZ e compensação de fuso horário de UTC. No BigQuery, é preciso realizar uma conversão de fuso horário manualmente para corresponder ao recurso `TIMESTAMP WITH LOCAL TIME ZONE` da Oracle.
`TIMESTAMP(x)`	`TIMESTAMP`	O BigQuery oferece suporte à precisão de microssegundos (10^-6) em comparação com a Oracle, que é compatível com a precisão variando de 0 a 9. O BigQuery oferece suporte para o nome de região de fuso horário de um banco de dados TZ e compensação de fuso horário de UTC. No BigQuery, é preciso realizar uma conversão de fuso horário manualmente para corresponder ao recurso `TIMESTAMP WITH LOCAL TIME ZONE` da Oracle.
`TIMESTAMP WITH TIME ZONE`	`TIMESTAMP`	O BigQuery oferece suporte à precisão de microssegundos (10^-6) em comparação com a Oracle, que é compatível com a precisão variando de 0 a 9. O BigQuery oferece suporte para o nome de região de fuso horário de um banco de dados TZ e compensação de fuso horário de UTC. No BigQuery, é preciso realizar uma conversão de fuso horário manualmente para corresponder ao recurso `TIMESTAMP WITH LOCAL TIME ZONE` da Oracle.
`TIMESTAMP WITH LOCAL TIME ZONE`	`TIMESTAMP`	O BigQuery oferece suporte à precisão de microssegundos (10^-6) em comparação com a Oracle, que é compatível com a precisão variando de 0 a 9. O BigQuery oferece suporte para o nome de região de fuso horário de um banco de dados TZ e compensação de fuso horário de UTC. No BigQuery, é preciso realizar uma conversão de fuso horário manualmente para corresponder ao recurso `TIMESTAMP WITH LOCAL TIME ZONE` da Oracle.
`INTERVAL YEAR TO MONTH`	`STRING`	Os valores de intervalo podem ser armazenados como tipo de dados `STRING` no BigQuery.
`INTERVAL DAY TO SECOND`	`STRING`	Os valores de intervalo podem ser armazenados como tipo de dados `STRING` no BigQuery.
`RAW`	`BYTES`	O tipo de dados `BYTES` pode ser usado para armazenar dados binários de comprimento variável. Se esse campo não for consultado e usado em análise, a melhor opção é armazenar dados binários no Cloud Storage.
`LONG RAW`	`BYTES`	O tipo de dados `BYTES` pode ser usado para armazenar dados binários de comprimento variável. Se esse campo não for consultado e usado em análise, a melhor opção é armazenar dados binários no Cloud Storage.
`ROWID`	`STRING`	Esses tipos de dados são usados internamente pela Oracle para especificar endereços exclusivos em linhas de uma tabela. Geralmente, o campo `ROWID` ou `UROWID` não deve ser usado em aplicativos. No entanto, se esse for o caso, o tipo de dado `STRING` poderá ser usado para armazenar esses dados.

Formatação de tipo

O Oracle SQL usa um conjunto de formatos padrão definidos como parâmetros para exibir expressões e dados de colunas e para conversões entre tipos de dados. Por exemplo, NLS_DATE_FORMAT definido como YYYY/MM/DD formata datas como YYYY/MM/DD por padrão. Veja mais informações sobre as configurações do NLS na documentação on-line da Oracle. No BigQuery, não há parâmetros de inicialização.

Por padrão, o BigQuery espera que todos os dados de origem sejam UTF-8 codificados durante o carregamento. Opcionalmente, se houver arquivos CSV com dados codificados no formato ISO-8859-1, será possível especificar a codificação explicitamente na importação dos dados. Com isso, o BigQuery consegue converter seus dados adequadamente no formato UTF-8 durante o processo de importação.

Só é possível importar dados que estejam nos formatos ISO-8859-1 ou UTF-8. O BigQuery armazena e retorna os dados como codificados em UTF-8. O formato pretendido ou o fuso horário pode ser definido nas funções DATE e TIMESTAMP.

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

Ao converter os elementos de formatação de carimbo de data/hora e de data da Oracle para o BigQuery, veja as diferenças de fuso horário entre TIMESTAMP e DATETIME, conforme resumido na tabela a seguir.

Não há parênteses nos formatos da Oracle porque os formatos (CURRENT_*) são palavras-chave, não funções.

Oracle	BigQuery	Observações
`CURRENT_TIMESTAMP`	As informações de `TIMESTAMP` na Oracle podem ter diferentes informações de fuso horário, que são definidas usando `WITH TIME ZONE` na variável `TIME_ZONE` de definição ou configuração de coluna.	Se possível, use a função `CURRENT_TIMESTAMP()`, no formato ISO. No entanto, o formato de saída sempre mostra o fuso horário UTC. Internamente, o BigQuery não tem um fuso horário. Observe os seguintes detalhes sobre as diferenças no formato ISO. `DATETIME` é formatado com base nas convenções do canal de saída. Na ferramenta de linha de comando do BigQuery e no console do BigQuery, o `DATETIME` é formatado usando um separador `T` de acordo com o RFC 3339. No entanto, em Python e Java JDBC, um espaço é usado como separador. Se você quiser usar um formato explícito, use a função `FORMAT_DATETIME`(), que transforma uma transmissão explícita em uma string. Por exemplo, a expressão a seguir sempre retorna um separador de espaço: `CAST(CURRENT_DATETIME() AS STRING)`
`CURRENT_DATE SYSDATE`	O Oracle usa dois tipos: tipo 12 tipo 13 O Oracle usa o tipo 12 ao armazenar datas. Internamente, esses são números com tamanho fixo. A Oracle usa o tipo 13 quando um é retornado por `SYSDATE or CURRENT_DATE`.	O BigQuery tem um formato `DATE` separado que sempre retorna uma data no formato ISO 8601. `DATE_FROM_UNIX_DATE` não pode ser usado porque é baseado em 1970.
`CURRENT_DATE-3`	Os valores de data são representados como números inteiros. A Oracle é compatível com operadores aritméticos para tipos de data.	Para tipos de data, use `DATE_ADD`() ou `DATE_SUB`(). O BigQuery usa operadores aritméticos para tipos de dados: `INT64`, `NUMERIC` e `FLOAT64`.
`NLS_DATE_FORMAT`	Defina o formato de data da sessão ou do sistema.	O BigQuery sempre usa o ISO 8601. Portanto, converta datas e horários da Oracle.

Sintaxe das consultas

Nesta seção, abordamos as diferenças na sintaxe de consulta entre a Oracle e o BigQuery.

instruções `SELECT`

A maioria das instruções SELECT da Oracle é compatível com o BigQuery.

Funções, operadores e expressões

As seções a seguir listam mapeamentos entre funções da Oracle e equivalentes do BigQuery.

Operadores de comparação

Os operadores de comparação Oracle e BigQuery são compatíveis com ANSI SQL:2011. Os operadores de comparação na tabela abaixo são os mesmos no BigQuery e na Oracle. É possível usar REGEXP_CONTAINS em vez de REGEXP_LIKE no BigQuery.

Operador	Descrição
`"="`	Igual
`<>`	Diferente
`!=`	Diferente
`>`	Maior que
`>=`	Maior que ou igual a
`<`	Menor que
`<=`	Menor que ou igual
`IN ( )`	Corresponde a um valor em uma lista
`NOT`	Nega uma condição
`BETWEEN`	Dentro de um intervalo (inclusivo)
`IS NULL`	Valor `NULL`
`IS NOT NULL`	O valor não é `NULL`
`LIKE`	Correspondência de padrão com %
`EXISTS`	A condição será atendida se a subconsulta retornar pelo menos uma linha

Os operadores na tabela são os mesmos no BigQuery e na Oracle.

Expressões e funções lógicas

Oracle	BigQuery
`CASE`	`CASE`
`COALESCE`	`COALESCE(expr1, ..., exprN)`
`DECODE`	`CASE.. WHEN.. END`
`NANVL`	`IFNULL`
`FETCH NEXT>`	`LIMIT`
`NULLIF`	`NULLIF(expression, expression_to_match)`
`NVL`	`IFNULL(expr, 0), COALESCE(exp, 0)`
`NVL2`	`IF(expr, true_result, else_result)`

Funções de agregação

A tabela a seguir mostra os mapeamentos entre funções comuns agregadas da Oracle, agregadas estáticas e agregadas aproximadas com os equivalentes do BigQuery:

Oracle	BigQuery
`ANY_VALUE` (da Oracle 19c)	`ANY_VALUE`
`APPROX_COUNT`	`HLL_COUNT set of functions with specified precision`
`APPROX_COUNT_DISTINCT`	`APPROX_COUNT_DISTINCT`
`APPROX_COUNT_DISTINCT_AGG`	`APPROX_COUNT_DISTINCT`
`APPROX_COUNT_DISTINCT_DETAIL`	`APPROX_COUNT_DISTINCT`
`APPROX_PERCENTILE(percentile) WITHIN GROUP (ORDER BY expression)`	`APPROX_QUANTILES(expression, 100)[ OFFSET(CAST(TRUNC(percentile * 100) as INT64))]` O BigQuery não é compatível com os outros argumentos definidos pela Oracle.
<codeAPPROX_PERCENTILE_AGG	`APPROX_QUANTILES(expression, 100)[ OFFSET(CAST(TRUNC(percentile * 100) as INT64))]`
`APPROX_PERCENTILE_DETAIL`	`APPROX_QUANTILES(expression, 100)[OFFSET(CAST(TRUNC(percentile * 100) as INT64))]`
`APPROX_SUM`	`APPROX_TOP_SUM(expression, weight, number)`
`AVG`	`AVG`
`BIT_COMPLEMENT`	Lógica binária não operadora: ~
`BIT_OR`	`BIT_OR, X \| Y`
`BIT_XOR`	`BIT_XOR, X ^ Y`
`BITAND`	`BIT_AND, X & Y`
`CARDINALITY`	`COUNT`
`COLLECT`	O BigQuery não é compatível com `TYPE AS TABLE OF`. Considere usar `STRING_AGG()` ou `ARRAY_AGG()` no BigQuery
`CORR/CORR_K/` `CORR_S`	`CORR`
`COUNT`	`COUNT`
`COVAR_POP`	`COVAR_POP`
`COVAR_SAMP`	`COVAR_SAMP`
`FIRST`	Não existe implicitamente no BigQuery. Considere usar funções definidas pelo usuário (UDF).
`GROUP_ID`	Não usado no BigQuery
`GROUPING`	Não usado no BigQuery
`GROUPING_ID`	Não usado no BigQuery.
`LAST`	Não existe implicitamente no BigQuery. Considere usar UDFs.
`LISTAGG`	`STRING_AGG, ARRAY_CONCAT_AGG(expression [ORDER BY key [{ASC\|DESC}] [, ... ]] [LIMIT n])`
`MAX`	`MAX`
`MIN`	`MIN`
`OLAP_CONDITION`	Específico da Oracle, não existe no BigQuery.
`OLAP_EXPRESSION`	Específico da Oracle, não existe no BigQuery.
`OLAP_EXPRESSION_BOOL`	Específico da Oracle, não existe no BigQuery.
`OLAP_EXPRESSION_DATE`	Específico da Oracle, não existe no BigQuery.
`OLAP_EXPRESSION_TEXT`	Específico da Oracle, não existe no BigQuery.
`OLAP_TABLE`	Específico da Oracle, não existe no BigQuery.
`POWERMULTISET`	Específico da Oracle, não existe no BigQuery.
`POWERMULTISET_BY_CARDINALITY`	Específico da Oracle, não existe no BigQuery.
`QUALIFY`	Específico da Oracle, não existe no BigQuery.
`REGR_AVGX`	`AVG(` `IF(dep_var_expr is NULL` `OR ind_var_expr is NULL,` `NULL, ind_var_expr)` `)`
`REGR_AVGY`	`AVG(` `IF(dep_var_expr is NULL` `OR ind_var_expr is NULL,` `NULL, dep_var_expr)` `)`
`REGR_COUNT`	`SUM(` `IF(dep_var_expr is NULL` `OR ind_var_expr is NULL,` `NULL, 1)` `)`
`REGR_INTERCEPT`	`AVG(dep_var_expr) - AVG(ind_var_expr) * (COVAR_SAMP(ind_var_expr,dep_var_expr) / VARIANCE(ind_var_expr) )`
`REGR_R2`	`(COUNT(dep_var_expr) * SUM(ind_var_expr * dep_var_expr) - SUM(dep_var_expr) * SUM(ind_var_expr)) / SQRT( (COUNT(ind_var_expr) * SUM(POWER(ind_var_expr, 2)) * POWER(SUM(ind_var_expr),2)) * (COUNT(dep_var_expr) * SUM(POWER(dep_var_expr, 2)) * POWER(SUM(dep_var_expr), 2)))`
`REGR_SLOPE`	`COVAR_SAMP(ind_var_expr,` `dep_var_expr)` `/ VARIANCE(ind_var_expr)`
`REGR_SXX`	`SUM(POWER(ind_var_expr, 2)) - COUNT(ind_var_expr) * POWER(AVG(ind_var_expr),2)`
`REGR_SXY`	`SUM(ind_var_exprdep_var_expr) - COUNT(ind_var_expr) AVG(ind) * AVG(dep_var_expr)`
`REGR_SYY`	`SUM(POWER(dep_var_expr, 2)) - COUNT(dep_var_expr) * POWER(AVG(dep_var_expr),2)`
`ROLLUP`	`ROLLUP`
`STDDEV_POP`	`STDDEV_POP`
`STDDEV_SAMP`	`STDDEV_SAMP, STDDEV`
`SUM`	`SUM`
`VAR_POP`	`VAR_POP`
`VAR_SAMP`	`VAR_SAMP, VARIANCE`
`WM_CONCAT`	`STRING_AGG`

O BigQuery oferece as seguintes funções extras de agregação:

Funções analíticas

A tabela a seguir mostra mapeamentos entre funções analíticas comuns e de agregação da Oracle e as equivalentes do BigQuery.

Oracle	BigQuery
`AVG`	`AVG`
`BIT_COMPLEMENT`	Lógica binária não operadora: ~
`BIT_OR`	`BIT_OR, X \| Y`
`BIT_XOR`	`BIT_XOR, X ^ Y`
`BITAND`	`BIT_AND, X & Y`
`BOOL_TO_INT`	`CAST(X AS INT64)`
`COUNT`	`COUNT`
`COVAR_POP`	`COVAR_POP`
`COVAR_SAMP`	`COVAR_SAMP`
`CUBE_TABLE`	Não é compatível com o BigQuery. Use uma ferramenta de BI ou uma UDF personalizada
`CUME_DIST`	`CUME_DIST`
`DENSE_RANK(ANSI)`	`DENSE_RANK`
`FEATURE_COMPARE`	Não existe implicitamente no BigQuery. Use UDFs e o BigQuery ML
`FEATURE_DETAILS`	Não existe implicitamente no BigQuery. Use UDFs e o BigQuery ML
`FEATURE_ID`	Não existe implicitamente no BigQuery. Use UDFs e o BigQuery ML
`FEATURE_SET`	Não existe implicitamente no BigQuery. Use UDFs e o BigQuery ML
`FEATURE_VALUE`	Não existe implicitamente no BigQuery. Use UDFs e o BigQuery ML
`FIRST_VALUE`	`FIRST_VALUE`
`HIER_CAPTION`	O BigQuery não oferece suporte a consultas hierárquicas.
`HIER_CHILD_COUNT`	O BigQuery não oferece suporte a consultas hierárquicas.
`HIER_COLUMN`	O BigQuery não oferece suporte a consultas hierárquicas.
`HIER_DEPTH`	O BigQuery não oferece suporte a consultas hierárquicas.
`HIER_DESCRIPTION`	O BigQuery não oferece suporte a consultas hierárquicas.
`HIER_HAS_CHILDREN`	O BigQuery não oferece suporte a consultas hierárquicas.
`HIER_LEVEL`	O BigQuery não oferece suporte a consultas hierárquicas.
`HIER_MEMBER_NAME`	O BigQuery não oferece suporte a consultas hierárquicas.
`HIER_ORDER`	O BigQuery não oferece suporte a consultas hierárquicas.
`HIER_UNIQUE_MEMBER_NAME`	O BigQuery não oferece suporte a consultas hierárquicas.
`LAST_VALUE`	`LAST_VALUE`
`LAG`	`LAG`
`LEAD`	`LEAD`
`LISTAGG`	`ARRAY_AGG STRING_AGG ARRAY_CONCAT_AGG`
`MATCH_NUMBER`	O reconhecimento e o cálculo de padrões podem ser feitos com expressões regulares e UDFs no BigQuery
`MATCH_RECOGNIZE`	O reconhecimento e o cálculo de padrões podem ser feitos com expressões regulares e UDFs no BigQuery
`MAX`	`MAX`
`MEDIAN`	`PERCENTILE_CONT(x, 0.5 RESPECT NULLS) OVER()`
`MIN`	`MIN`
`NTH_VALUE`	`NTH_VALUE (value_expression, constant_integer_expression [{RESPECT \| IGNORE} NULLS])`
`NTILE`	`NTILE(constant_integer_expression)`
`PERCENT_RANK PERCENT_RANKM`	`PERCENT_RANK`
`PERCENTILE_CONT PERCENTILE_DISC`	`PERCENTILE_CONT`
`PERCENTILE_CONT PERCENTILE_DISC`	`PERCENTILE_DISC`
`PRESENTNNV`	Específico da Oracle, não existe no BigQuery.
`PRESENTV`	Específico da Oracle, não existe no BigQuery.
`PREVIOUS`	Específico da Oracle, não existe no BigQuery.
`RANK`(ANSI)	`RANK`
`RATIO_TO_REPORT(expr) OVER (partition clause)`	`expr / SUM(expr) OVER (partition clause)`
`ROW_NUMBER`	`ROW_NUMBER`
`STDDEV_POP`	`STDDEV_POP`
`STDDEV_SAMP`	`STDDEV_SAMP, STDDEV`
`SUM`	`SUM`
`VAR_POP`	`VAR_POP`
`VAR_SAMP`	`VAR_SAMP, VARIANCE`
`VARIANCE`	`VARIANCE()`
`WIDTH_BUCKET`	UDF pode ser usado.

Funções de data/hora

A tabela a seguir mostra mapeamentos entre funções comuns de data/hora da Oracle e os equivalentes do BigQuery.

Oracle	BigQuery
`ADD_MONTHS(date, integer)`	`DATE_ADD(date, INTERVAL integer MONTH),` Se a data for uma `TIMESTAMP`, você pode usar `EXTRACT(DATE FROM TIMESTAMP_ADD(date, INTERVAL integer MONTH))`
`CURRENT_DATE`	`CURRENT_DATE`
`CURRENT_TIME`	`CURRENT_TIME`
`CURRENT_TIMESTAMP`	`CURRENT_TIMESTAMP`
`DATE - k`	`DATE_SUB(date_expression, INTERVAL k DAY)`
`DATE + k`	`DATE_ADD(date_expression, INTERVAL k DAY)`
`DBTIMEZONE`	O BigQuery não oferece suporte ao fuso horário do banco de dados.
`EXTRACT`	`EXTRACT(DATE), EXTRACT(TIMESTAMP)`
`LAST_DAY`	`DATE_SUB( DATE_TRUNC( DATE_ADD( date_expression, INTERVAL 1 MONTH ), MONTH ), INTERVAL 1 DAY )`
`LOCALTIMESTAMP`	O BigQuery não é compatível com configurações de fuso horário.
`MONTHS_BETWEEN`	`DATE_DIFF(date_expression, date_expression, MONTH)`
`NEW_TIME`	`DATE(timestamp_expression, time zone) TIME(timestamp, time zone) DATETIME(timestamp_expression, time zone)`
`NEXT_DAY`	`DATE_ADD( DATE_TRUNC( date_expression, WEEK(day_value) ), INTERVAL 1 WEEK )`
`SYS_AT_TIME_ZONE`	`CURRENT_DATE([time_zone])`
`SYSDATE`	`CURRENT_DATE()`
`SYSTIMESTAMP`	`CURRENT_TIMESTAMP()`
`TO_DATE`	`PARSE_DATE`
`TO_TIMESTAMP`	`PARSE_TIMESTAMP`
`TO_TIMESTAMP_TZ`	`PARSE_TIMESTAMP`
`TZ_OFFSET`	Não é compatível com o BigQuery. Use uma UDF personalizada.
`WM_CONTAINS` `WM_EQUALS` `WM_GREATERTHAN` `WM_INTERSECTION` `WM_LDIFF` `WM_LESSTHAN` `WM_MEETS` `WM_OVERLAPS` `WM_RDIFF`	Os períodos não são usados no BigQuery. As UDFs podem ser usadas para comparar dois períodos.

O BigQuery oferece as seguintes funções extras de data/hora:

Funções de string

A tabela a seguir mostra os mapeamentos entre as funções de string da Oracle e os equivalentes do BigQuery:

Oracle	BigQuery
`ASCII`	`TO_CODE_POINTS(string_expr)[OFFSET(0)]`
`ASCIISTR`	O BigQuery não é compatível com UTF-16
`RAWTOHEX`	`TO_HEX`
`LENGTH`	`CHAR_LENGTH`
`LENGTH`	`CHARACTER_LENGTH`
`CHR`	`CODE_POINTS_TO_STRING( [mod(numeric_expr, 256)] )`
`COLLATION`	Não existe no BigQuery. O BigQuery não oferece suporte para COLLATE em DML
`COMPOSE`	Função personalizada definida pelo usuário.
`CONCAT, (\|\| operator)`	`CONCAT`
`DECOMPOSE`	Função personalizada definida pelo usuário.
`ESCAPE_REFERENCE (UTL_I18N)`	Não é compatível com o BigQuery. Considere usar uma função definida pelo usuário.
`INITCAP`	`INITCAP`
`INSTR/INSTR2/INSTR4/INSTRB/INSTRC`	Função personalizada definida pelo usuário.
`LENGTH/LENGTH2/LENGTH4/LENGTHB/LENGTHC`	`LENGTH`
`LOWER`	`LOWER`
`LPAD`	`LPAD`
`LTRIM`	`LTRIM`
`NLS_INITCAP`	Função personalizada definida pelo usuário.
`NLS_LOWER`	`LOWER`
`NLS_UPPER`	`UPPER`
`NLSSORT`	Específico da Oracle, não existe no BigQuery.
`POSITION`	`STRPOS(string, substring)`
`PRINTBLOBTOCLOB`	Específico da Oracle, não existe no BigQuery.
`REGEXP_COUNT`	`ARRAY_LENGTH(REGEXP_EXTRACT_ALL(value, regex))`
`REGEXP_INSTR`	`STRPOS(source_string, REGEXP_EXTRACT(source_string, regexp_string))` Observação: retorna a primeira ocorrência.
`REGEXP_REPLACE`	`REGEXP_REPLACE`
`REGEXP_LIKE`	`IF(REGEXP_CONTAINS,1,0)`
`REGEXP_SUBSTR`	`REGEXP_EXTRACT, REGEXP_EXTRACT_ALL`
`REPLACE`	`REPLACE`
`REVERSE`	`REVERSE`
`RIGHT`	`SUBSTR(source_string, -1, length)`
`RPAD`	`RPAD`
`RTRIM`	`RTRIM`
`SOUNDEX`	Não é compatível com o BigQuery. Use uma UDF personalizada
`STRTOK`	`SPLIT(instring, delimiter)[ORDINAL(tokennum)]` `Note: The entire delimiter string argument is used as a single delimiter. The default delimiter is a comma.`
`SUBSTR/SUBSTRB/SUBSTRC/SUBSTR2/SUBSTR4`	`SUBSTR`
`TRANSLATE`	`REPLACE`
`TRANSLATE USING`	`REPLACE`
`TRIM`	`TRIM`
`UNISTR`	`CODE_POINTS_TO_STRING`
`UPPER`	`UPPER`
`\|\|` (BARRAS VERTICAIS)	`CONCAT`

O BigQuery oferece as seguintes funções extras de string:

Funções matemáticas

A tabela a seguir mostra os mapeamentos entre as funções matemáticas da Oracle e os equivalentes do BigQuery:

Oracle	BigQuery
`ABS`	`ABS`
`ACOS`	`ACOS`
`ACOSH`	`ACOSH`
`ASIN`	`ASIN`
`ASINH`	`ASINH`
`ATAN`	`ATAN`
`ATAN2`	`ATAN2`
`ATANH`	`ATANH`
`CEIL`	`CEIL`
`CEILING`	`CEILING`
`COS`	`COS`
`COSH`	`COSH`
`EXP`	`EXP`
`FLOOR`	`FLOOR`
`GREATEST`	`GREATEST`
`LEAST`	`LEAST`
`LN`	`LN`
`LNNVL`	Use com `ISNULL`
`LOG`	`LOG`
`MOD (% operator)`	`MOD`
`POWER (** operator)`	`POWER, POW`
`DBMS_RANDOM.VALUE`	`RAND`
`RANDOMBYTES`	Não é compatível com o BigQuery. Use uma função personalizada de UDF e RAND
`RANDOMINTEGER`	`CAST(FLOOR(10*RAND()) AS INT64)`
`RANDOMNUMBER`	Não é compatível com o BigQuery. Use uma função personalizada de UDF e RAND
`REMAINDER`	`MOD`
`ROUND`	`ROUND`
`ROUND_TIES_TO_EVEN`	`ROUND()`
`SIGN`	`SIGN`
`SIN`	`SIN`
`SINH`	`SINH`
`SQRT`	`SQRT`
`STANDARD_HASH`	`FARM_FINGERPRINT, MD5, SHA1, SHA256, SHA512`
`STDDEV`	STDDEV
`TAN`	`TAN`
`TANH`	`TANH`
`TRUNC`	`TRUNC`
`NVL`	`IFNULL(expr, 0), COALESCE(exp, 0)`

O BigQuery oferece as seguintes funções matemáticas extras:

Funções de conversão de tipo

A tabela a seguir mostra os mapeamentos entre as funções de conversão do tipo da Oracle e os equivalentes do BigQuery.

Oracle	BigQuery
`BIN_TO_NUM`	`SAFE_CONVERT_BYTES_TO_STRING(value)` `CAST(x AS INT64)`
`BINARY2VARCHAR`	`SAFE_CONVERT_BYTES_TO_STRING(value)`
`CAST CAST_FROM_BINARY_DOUBLE CAST_FROM_BINARY_FLOAT CAST_FROM_BINARY_INTEGER CAST_FROM_NUMBER CAST_TO_BINARY_DOUBLE CAST_TO_BINARY_FLOAT CAST_TO_BINARY_INTEGER CAST_TO_NUMBER CAST_TO_NVARCHAR2 CAST_TO_RAW >CAST_TO_VARCHAR`	`CAST(expr AS typename)`
`CHARTOROWID`	Não é necessário especificar a Oracle.
`CONVERT`	O BigQuery não oferece suporte a conjuntos de caracteres. Use uma função personalizada definida pelo usuário.
`EMPTY_BLOB`	`BLOB` não é usado no BigQuery.
`EMPTY_CLOB`	`CLOB` não é usado no BigQuery.
`FROM_TZ`	Os tipos com fusos horários não são suportados no BigQuery. Use uma função definida pelo usuário e FORMAT_TIMESTAMP
`INT_TO_BOOL`	`CAST`
`IS_BIT_SET`	Não existe implicitamente no BigQuery. Use UDFs
`NCHR`	A UDF pode ser usada para ter um caractere equivalente ao binário
`NUMTODSINTERVAL`	O tipo de dados `INTERVAL` não é compatível com o BigQuery
`NUMTOHEX`	Não é compatível com o BigQuery. Use uma UDF personalizada e a função `TO_HEX`.
`NUMTOHEX2`
`NUMTOYMINTERVAL`	O tipo de dados `INTERVAL` não é compatível com o BigQuery.
`RAW_TO_CHAR`	Específico da Oracle, não existe no BigQuery.
`RAW_TO_NCHAR`	Específico da Oracle, não existe no BigQuery.
`RAW_TO_VARCHAR2`	Específico da Oracle, não existe no BigQuery.
`RAWTOHEX`	Específico da Oracle, não existe no BigQuery.
`RAWTONHEX`	Específico da Oracle, não existe no BigQuery.
`RAWTONUM`	Específico da Oracle, não existe no BigQuery.
`RAWTONUM2`	Específico da Oracle, não existe no BigQuery.
`RAWTOREF`	Específico da Oracle, não existe no BigQuery.
`REFTOHEX`	Específico da Oracle, não existe no BigQuery.
`REFTORAW`	Específico da Oracle, não existe no BigQuery.
`ROWIDTOCHAR`	`ROWID` é um tipo específico da Oracle e não existe no BigQuery. Esse valor precisa ser representado como uma string.
`ROWIDTONCHAR`	`ROWID` é um tipo específico da Oracle e não existe no BigQuery. Esse valor precisa ser representado como uma string.
`SCN_TO_TIMESTAMP`	`SCN` é um tipo específico da Oracle e não existe no BigQuery. Esse valor precisa ser representado como carimbo de data/hora.
`TO_ACLID TO_ANYLOB TO_APPROX_COUNT_DISTINCT TO_APPROX_PERCENTILE TO_BINARY_DOUBLE TO_BINARY_FLOAT TO_BLOB TO_CHAR TO_CLOB TO_DATE TO_DSINTERVAL TO_LOB TO_MULTI_BYTE TO_NCHAR TO_NCLOB TO_NUMBER TO_RAW TO_SINGLE_BYTE TO_TIME` TO_TIMESTAMP TO_TIMESTAMP_TZ TO_TIME_TZ TO_UTC_TIMEZONE_TZ TO_YMINTERVAL	`CAST(expr AS typename)` `PARSE_DATE` `PARSE_TIMESTAMP` Usa-se a sintaxe de cast em uma consulta para indicar que é preciso converter o tipo do resultado de uma expressão em algum outro tipo.
`TREAT`	Específico da Oracle, não existe no BigQuery.
`VALIDATE_CONVERSION`	Não é compatível com o BigQuery. Use uma UDF personalizada
`VSIZE`	Não é compatível com o BigQuery. Use uma UDF personalizada

Funções JSON

A tabela a seguir mostra os mapeamentos entre as funções JSON da Oracle e os equivalentes do BigQuery:

Oracle	BigQuery
`AS_JSON`	`TO_JSON_STRING(value[, pretty_print])`
`JSON_ARRAY`	Use UDFs e a função `TO_JSON_STRING`
`JSON_ARRAYAGG`	Use UDFs e a função `TO_JSON_STRING`
`JSON_DATAGUIDE`	Função personalizada definida pelo usuário.
`JSON_EQUAL`	Função personalizada definida pelo usuário.
`JSON_EXIST`	Use UDFs e `JSON_EXTRACT` ou `JSON_EXTRACT_SCALAR`
`JSON_MERGEPATCH`	Função personalizada definida pelo usuário.
`JSON_OBJECT`	Não é compatível com o BigQuery.
`JSON_OBJECTAGG`	Não é compatível com o BigQuery.
`JSON_QUERY`	Use UDFs e `JSON_EXTRACT` ou `JSON_EXTRACT_SCALAR`.
`JSON_TABLE`	Função personalizada definida pelo usuário.
`JSON_TEXTCONTAINS`	Use UDFs e `JSON_EXTRACT` ou `JSON_EXTRACT_SCALAR`.
`JSON_VALUE`	`JSON_EXTRACT_SCALAR`

Funções XML

O BigQuery não fornece funções XML implícitas. O XML pode ser carregado no BigQuery, já que a string e as UDFs podem ser usadas para analisar o XML. Como alternativa, o processamento de XML é feito por uma ferramenta ETL/ELT como o Dataflow. A lista a seguir mostra as funções XML da Oracle:

Oracle	BigQuery
`DELETEXML`	UDFs do BigQuery ou ferramenta de ETL como o Dataflow podem ser usadas para processar XML.
`ENCODE_SQL_XML`
`EXISTSNODE`
`EXTRACTCLOBXML`
`EXTRACTVALUE`
`INSERTCHILDXML`
`INSERTCHILDXMLAFTER`
`INSERTCHILDXMLBEFORE`
`INSERTXMLAFTER`
`INSERTXMLBEFORE`
`SYS_XMLAGG`
`SYS_XMLANALYZE`
`SYS_XMLCONTAINS`
`SYS_XMLCONV`
`SYS_XMLEXNSURI`
`SYS_XMLGEN`
`SYS_XMLI_LOC_ISNODE`
`SYS_XMLI_LOC_ISTEXT`
`SYS_XMLINSTR`
`SYS_XMLLOCATOR_GETSVAL`
`SYS_XMLNODEID`
`SYS_XMLNODEID_GETLOCATOR`
`SYS_XMLNODEID_GETOKEY`
`SYS_XMLNODEID_GETPATHID`
`SYS_XMLNODEID_GETPTRID`
`SYS_XMLNODEID_GETRID`
`SYS_XMLNODEID_GETSVAL`
`SYS_XMLT_2_SC`
`SYS_XMLTRANSLATE`
`SYS_XMLTYPE2SQL`
`UPDATEXML`
`XML2OBJECT`
`XMLCAST`
`XMLCDATA`
`XMLCOLLATVAL`
`XMLCOMMENT`
`XMLCONCAT`
`XMLDIFF`
`XMLELEMENT`
`XMLEXISTS`
`XMLEXISTS2`
`XMLFOREST`
`XMLISNODE`
`XMLISVALID`
`XMLPARSE`
`XMLPATCH`
`XMLPI`
`XMLQUERY`
`XMLQUERYVAL`
`XMLSERIALIZE`
`XMLTABLE`
`XMLTOJSON`
`XMLTRANSFORM`
`XMLTRANSFORMBLOB`
`XMLTYPE`

Funções de machine learning

As funções de machine learning (ML) na Oracle e no BigQuery são diferentes. A Oracle requer licenças e pacotes de análise avançados para fazer ML no banco de dados. A Oracle usa o pacote DBMS_DATA_MINING para ML. Para converter jobs de mineradores de dados da Oracle, é preciso reescrever o código. Escolha ofertas abrangentes de produtos de IA do Google, como BigQuery ML, APIs AI, incluindo Speech-to-Text, Text-to-Speech, Dialogflow, Cloud Translation, NLP, Cloud Vision e API Timeseries Insights, AutoML, AutoML Tables ou AI Platform. Os notebooks gerenciados pelo usuário do Google podem ser usados como um ambiente de desenvolvimento para cientistas de dados, e o AI Platform Training do Google pode ser usado para executar treinamentos e pontuação de cargas de trabalho em escala. A tabela a seguir mostra as funções do Oracle ML:

Oracle	BigQuery
`CLASSIFIER`	Veja opções de regressão e classificador de machine learning no BigQuery ML.
`CLUSTER_DETAILS`
`CLUSTER_DISTANCE`
`CLUSTER_ID`
`CLUSTER_PROBABILITY`
`CLUSTER_SET`
`PREDICTION`
`PREDICTION_BOUNDS`
`PREDICTION_COST`
`PREDICTION_DETAILS`
`PREDICTION_PROBABILITY`
`PREDICTION_SET`

Funções de segurança

A tabela a seguir mostra as funções para identificar o usuário na Oracle e no BigQuery:

Oracle	BigQuery
`UID`	`SESSION_USER`
`USER/SESSION_USER/CURRENT_USER`	`SESSION_USER()`

Funções "set" ou "array"

A tabela a seguir mostra as funções "set" ou "array" no Oracle e os equivalentes delas no BigQuery:

Oracle	BigQuery
`MULTISET`	`ARRAY_AGG`
`MULTISET EXCEPT`	`ARRAY_AGG([DISTINCT] expression)`
`MULTISET INTERSECT`	`ARRAY_AGG([DISTINCT])`
`MULTISET UNION`	`ARRAY_AGG`

Funções de janela

A tabela a seguir mostra as funções de janela na Oracle e os equivalentes no BigQuery.

Oracle	BigQuery
`LAG`	`LAG (value_expression[, offset [, default_expression]])`
`LEAD`	`LEAD (value_expression[, offset [, default_expression]])`

Consultas hierárquicas ou recorrentes

Consultas hierárquicas ou recursivas não são usadas no BigQuery. Se a profundidade da hierarquia for conhecida, uma funcionalidade semelhante pode ser alcançada com mesclagens, conforme ilustrado no exemplo a seguir. Outra solução seria usar a API BigQueryStorage e o Spark.

select
  array(
    select e.update.element
    union all
    select c1 from e.update.element.child as c1
    union all
    select c2 from e.update.element.child as c1, c1.child as c2
    union all
    select c3 from e.update.element.child as c1, c1.child as c2, c2.child as c3
    union all
    select c4 from e.update.element.child as c1, c1.child as c2, c2.child as c3, c3.child as c4
    union all
    select c5 from e.update.element.child as c1, c1.child as c2, c2.child as c3, c3.child as c4, c4.child as c5
  ) as flattened,
  e as event
from t, t.events as e

A tabela a seguir mostra as funções hierárquicas da Oracle.

Oracle	BigQuery
`DEPTH`	Consultas hierárquicas não são usadas no BigQuery.
`PATH`
`SYS_CONNECT_BY_PATH (hierarchical)`

Funções UTL

O pacote UTL_File é usado principalmente para ler e gravar arquivos do sistema operacional de PL/SQL. O Cloud Storage pode ser usado para qualquer tipo de preparo de arquivo bruto. As tabelas externas e o carregamento e a exportação do BigQuery precisam ser usados para ler e gravar arquivos no Cloud Storage e a partir dele. Para mais informações, consulte Introdução a fontes de dados externas.

Funções espaciais

A análise geoespacial do BigQuery pode ser usada para substituir a funcionalidade espacial. Existem funções e tipos SDO_* na Oracle, como SDO_GEOM_KEY, SDO_GEOM_MBR e SDO_GEOM_MMB. Essas funções são usadas para análise espacial. Use a análise geoespacial para fazer análises espaciais.

Sintaxe DML

Esta seção aborda as diferenças na sintaxe da linguagem de gerenciamento de dados entre a Oracle e o BigQuery.

Instrução `INSERT`

A maioria das instruções INSERT da Oracle é compatível com o BigQuery. A tabela a seguir mostra as exceções.

Os scripts DML no BigQuery têm semânticas de consistência ligeiramente diferentes das instruções equivalentes na Oracle. Para uma visão geral do isolamento de snapshot e do processamento de sessões e transações, consulte a seção CREATE [UNIQUE] INDEX section em outras partes deste documento.

Oracle BigQuery

Oracle	BigQuery
`INSERT INTO table VALUES (...);`	`INSERT INTO table (...) VALUES (...);` A Oracle oferece uma palavra-chave `DEFAULT` para colunas não anuláveis. Observação: no BigQuery, a omissão de nomes de coluna na instrução `INSERT` funcionará somente se os valores de todas as colunas na tabela de destino forem incluídos em ordem crescente com base nas posições ordinais.
`INSERT INTO table VALUES (1,2,3); INSERT INTO table VALUES (4,5,6); INSERT INTO table VALUES (7,8,9); INSERT ALL INTO table (col1, col2) VALUES ('val1_1', 'val1_2') INTO table (col1, col2) VALUES ('val2_1', 'val2_2') INTO table (col1, col2) VALUES ('val3_1', 'val3_2') . . . SELECT 1 FROM DUAL;`	`INSERT INTO table VALUES (1,2,3), (4,5,6), (7,8,9);` 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 `INSERT`) usando uma instrução `MERGE`. Use `CREATE TABLE ... AS SELECT` para criar e preencher novas tabelas.

INSERT INTO table VALUES (...);

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

A Oracle oferece uma palavra-chave DEFAULT para colunas não anuláveis.

Observação: no BigQuery, a omissão de nomes de coluna na instrução INSERT funcionará somente se os valores de todas as colunas na tabela de destino forem incluídos em ordem crescente com base nas posições ordinais.

INSERT INTO table VALUES (1,2,3);

    INSERT INTO table VALUES (4,5,6);

    INSERT INTO table VALUES (7,8,9);

    INSERT ALL

    INTO table (col1, col2) VALUES ('val1_1', 'val1_2')

    INTO table (col1, col2) VALUES ('val2_1', 'val2_2')

    INTO table (col1, col2) VALUES ('val3_1', 'val3_2')

    .

    .

    .

    SELECT 1 FROM DUAL;

INSERT INTO table VALUES (1,2,3),
(4,5,6),
(7,8,9);

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 INSERT) usando uma instrução MERGE.
Use CREATE TABLE ... AS SELECT para criar e preencher novas tabelas.

Instrução `UPDATE`

As instruções UPDATE da Oracle são compatíveis principalmente com o BigQuery. No entanto, no BigQuery, a instrução UPDATE precisa ter uma cláusula WHERE.

Como prática recomendada, é preciso preferir instruções DML em lote a várias instruções UPDATE e INSERT sozinhas. Os scripts DML no BigQuery têm uma semântica de consistência ligeiramente diferente das declarações equivalentes na Oracle. Para uma visão geral do isolamento de snapshot e do processamento de sessões e transações, consulte a seção CREATE INDEX deste documento.

A tabela a seguir mostra instruções UPDATE da Oracle e instruções do BigQuery que realizam as mesmas tarefas.

No BigQuery, a instrução UPDATE precisa ter uma cláusula WHERE. Para mais informações sobre UPDATE no BigQuery, consulte os exemplos de ATUALIZAÇÃO do BigQuery na documentação do DML.

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

As instruções DELETE e TRUNCATE são maneiras de remover linhas de uma tabela sem afetar o esquema da tabela. TRUNCATE não é usado no BigQuery. No entanto, é possível usar as instruções DELETE para ter o mesmo efeito.

No BigQuery, a instrução DELETE precisa ter uma cláusula WHERE. Para mais informações sobre DELETE no BigQuery, consulte os exemplos de DELETE do BigQuery na documentação do DML.

Oracle	BigQuery
`DELETE database.table;`	`DELETE FROM table WHERE TRUE;`

Instrução `MERGE`

A instrução MERGE pode combinar operações INSERT, UPDATE e DELETE em uma única instrução UPSERT e executar as operações de maneira atômica. A operação MERGE precisa corresponder, no máximo, a uma linha de origem para cada linha de destino. O BigQuery e a Oracle seguem a sintaxe ANSI.

No entanto, os scripts DML no BigQuery têm semânticas de consistência ligeiramente diferentes das instruções equivalentes na Oracle.

Sintaxe DDL

Nesta seção, abordamos as diferenças na sintaxe da linguagem de definição de dados entre a Oracle e o BigQuery.

Instrução `CREATE TABLE`

A maioria das instruções CREATE TABLE da Oracle é compatível com o BigQuery, exceto as seguintes restrições e elementos de sintaxe, que não são usados no BigQuery:

STORAGE
TABLESPACE
DEFAULT
GENERATED ALWAYS AS
ENCRYPT
PRIMARY KEY (col, ...). Veja mais informações em: CREATE INDEX
UNIQUE INDEX. Veja mais informações em: CREATE INDEX
CONSTRAINT..REFERENCES
DEFAULT
PARALLEL
COMPRESS

Para mais informações sobre CREATE TABLE no BigQuery, consulte os exemplos de CREATE TABLE do BigQuery.

Atributos e opções de coluna

As colunas de identidade são introduzidas com a versão 12c da Oracle, que permite o incremento automático em uma coluna. Isso não é usado no BigQuery e é possível fazer isso com a seguinte maneira em lote. Para mais informações sobre chaves alternativas e dimensões com alterações lentas (SCD, na sigla em inglês), consulte os seguintes guias:

Oracle	BigQuery
`CREATE TABLE table ( id NUMBER GENERATED ALWAYS AS IDENTITY, description VARCHAR2(30) );`	`INSERT INTO dataset.table SELECT *, ROW_NUMBER() OVER () AS id FROM dataset.table`

Coluna de comentários

A Oracle usa a sintaxe Comment para adicionar comentários em colunas. Esse recurso pode ser implementado de maneira semelhante no BigQuery usando a descrição da coluna, conforme mostrado na tabela a seguir:

Oracle	BigQuery
`Comment on column table is 'column desc';`	`CREATE TABLE dataset.table ( col1 STRING OPTIONS(description="column desc") );`

Tabelas temporárias

A Oracle é compatível com tabelas temporárias, que geralmente são usadas para armazenar resultados intermediários em scripts. As tabelas temporárias são compatíveis com o BigQuery.

Oracle	BigQuery
`CREATE GLOBAL TEMPORARY TABLE temp_tab (x INTEGER, y VARCHAR2(50)) ON COMMIT DELETE ROWS; COMMIT;`	`CREATE TEMP TABLE temp_tab ( x INT64, y STRING ); DELETE FROM temp_tab WHERE TRUE;`

Os seguintes elementos da Oracle não são usados no BigQuery:

ON COMMIT DELETE ROWS;
ON COMMIT PRESERVE ROWS;

Há também outras maneiras de emular tabelas temporárias no BigQuery:

Tempo de vida (TTL) do conjunto de dados: crie um conjunto de dados que tenha um curto tempo de vida, por exemplo, uma hora, para que as tabelas criadas no conjunto de dados sejam efetivamente temporárias, já que não permanecerão por mais tempo do que o tempo de vida do conjunto de dados. É possível prefixar todos os nomes de tabela neste conjunto de dados com temp para indicar claramente que as tabelas são temporárias.
Tempo de vida (TTL) da tabela: crie uma tabela que tenha um curto tempo de vida específico usando instruções DDL semelhantes a estas:
```
CREATE TABLE temp.name (col1, col2, ...)

OPTIONS(expiration_timestamp=TIMESTAMP_ADD(CURRENT_TIMESTAMP(), INTERVAL 1 HOUR));
```
Cláusula WITH: se uma tabela temporária for necessária apenas dentro do mesmo bloco, use um resultado temporário usando uma instrução ou subconsulta WITH.

Instrução `CREATE SEQUENCE`

As sequências não são usadas no BigQuery. Faça isso com a seguinte maneira em lote. Para mais informações sobre chaves alternativas e dimensões com alterações lentas (SCD, na sigla em inglês), consulte os seguintes guias:

INSERT INTO dataset.table
    SELECT *,
      ROW_NUMBER() OVER () AS id
      FROM dataset.table

Instrução `CREATE VIEW`

A tabela a seguir mostra equivalentes entre a Oracle e o BigQuery para a instrução CREATE VIEW.

Oracle	BigQuery	Observações
`CREATE VIEW view_name AS SELECT ...`	`CREATE VIEW view_name AS SELECT ...`
`CREATE OR REPLACE VIEW view_name AS SELECT ...`	`CREATE OR REPLACE VIEW` `view_name AS` `SELECT ...`
Não compatível	`CREATE VIEW IF NOT EXISTS` `view_name` `OPTIONS(view_option_list)` `AS SELECT ...`	Cria uma nova visualização somente se ela não existir no conjunto de dados especificado.

Instrução `CREATE MATERIALIZED VIEW`

No BigQuery, as operações de atualização de visualizações materializadas são feitas automaticamente. Não é necessário especificar opções de atualização (por exemplo, na confirmação ou na programação) no BigQuery. Para mais informações, consulte Introdução às visualizações materializadas.

Caso a tabela base continue mudando somente com anexos, a consulta que usa a visualização materializada (seja ela é referenciada ou selecionada pelo otimizador de consulta) verifica todas as visualizações materializadas mais um delta na tabela base desde a última visualização. Isso significa que as consultas são mais rápidas e mais baratas.

Pelo contrário, se houver atualizações (DML UPDATE / MERGE) ou exclusões (DML DELETE, truncamento, expiração da partição) na tabela base desde a última atualização de visualização, a visualização materializada não será verificada. Assim, os custos da consulta não serão reduzidos até a próxima visualização ser atualizada. Basicamente, qualquer atualização ou exclusão na tabela base invalida o estado materializado da visualização.

Além disso, os dados do buffer de streaming da tabela base não são salvos na visualização materializada. O buffer de streaming ainda está sendo verificado completamente, independentemente de a visualização materializada ser usada.

A tabela a seguir mostra equivalentes entre a Oracle e o BigQuery para a instrução CREATE MATERIALIZED VIEW.

Oracle	BigQuery	Observações
`CREATE MATERIALIZED VIEW view_name REFRESH FAST NEXT sysdate + 7 AS SELECT … FROM TABLE_1`	`CREATE MATERIALIZED VIEW view_name AS SELECT ...`

Instrução `CREATE [UNIQUE] INDEX`

Nesta seção, descrevemos abordagens no BigQuery para saber como criar funcionalidades semelhantes aos índices na Oracle.

Indexação de desempenho

O BigQuery não precisa de índices explícitos, porque é um banco de dados orientado por colunas, com otimização de consulta e armazenamento. O BigQuery oferece funcionalidades como particionamento e clustering, bem como campos aninhados, que podem aumentar a eficiência e o desempenho da consulta otimizando como os dados são armazenados.

Indexação de consistência (UNIQUE, PRIMARY INDEX)

Na Oracle, um índice exclusivo pode ser usado para evitar linhas com chaves não exclusivas em uma tabela. Se um processo tentar inserir ou atualizar dados com um valor que já está no índice, a operação falhará com uma violação de índice.

Como o BigQuery não fornece índices explícitos, uma instrução MERGE pode ser usada para inserir somente registros exclusivos em uma tabela de destino de uma tabela de preparo e descartando registros duplicados. No entanto, não é possível impedir que um usuário com permissões de edição insira um registro duplicado.

Para gerar um erro para registros duplicados no BigQuery, use uma instrução MERGE da tabela de preparo, conforme mostrado no exemplo a seguir.

Oracle		BigQuery
`CREATE [UNIQUE] INDEX name;`		MERGE `prototype.FIN_MERGE` t \ USING `prototype.FIN_TEMP_IMPORT` m \ ON t.col1 = m.col1 \ AND t.col2 = m.col2 \ WHEN MATCHED THEN \ UPDATE SET t.col1 = ERROR(CONCAT('Encountered Error for ', m.col1, ' ', m.col2)) \ WHEN NOT MATCHED THEN \ INSERT (col1,col2,col3,col4,col5,col6,col7,col8) VALUES(col1,col2,col3,col4,col5,col6, CURRENT_TIMESTAMP(),CURRENT_TIMESTAMP());

Com mais frequência, os usuários preferem remover cópias duplicadas de maneira independente para encontrar erros nos sistemas downstream.

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

Bloqueio

O BigQuery não tem um mecanismo de bloqueio como esse e pode executar consultas simultâneas, até sua cota. Somente instruções DML têm determinados limites de simultaneidade e podem exigir um bloqueio de tabela durante a execução em alguns cenários.

Instruções SQL procedurais

Nesta seção, descrevemos como converter instruções SQL processuais usadas em procedimentos, funções e gatilhos armazenados da Oracle para o BigQuery.

Instrução `CREATE PROCEDURE`

Há suporte para o procedimento armazenado como parte do BigQuery Scripting Beta.

Oracle	BigQuery	Observações
`CREATE PROCEDURE`	`CREATE PROCEDURE`	Assim como na Oracle, o BigQuery oferece suporte aos modos de argumento `IN, OUT, INOUT`. Outras especificações de sintaxe não são aceitas no BigQuery.
`CREATE OR REPLACE PROCEDURE`	`CREATE OR REPLACE PROCEDURE`
`CALL`	`CALL`

As seções a seguir descrevem maneiras de converter instruções processuais atuais da Oracle em instruções de script do BigQuery que têm funcionalidade semelhante.

Instrução `CREATE TRIGGER`

Gatilhos não são usados no BigQuery. A lógica do aplicativo baseada em linha precisa ser processada na camada do aplicativo. A funcionalidade do gatilho pode ser acessada usando a ferramenta de ingestão, o Pub/Sub e/ou o Cloud Run functions durante o tempo de ingestão ou utilizando verificações regulares.

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

A tabela a seguir mostra as instruções DECLARE da Oracle e os equivalentes do BigQuery.

Oracle	BigQuery
`DECLARE L_VAR NUMBER; BEGIN L_VAR := 10 + 20; END;`	`DECLARE L_VAR int64; BEGIN SET L_VAR = 10 + 20; SELECT L_VAR; END`
`SET var = value;`	`SET var = value;`

Declarações e operações do cursor

O BigQuery não é compatível com cursores. Portanto, as seguintes instruções não são usadas no BigQuery:

DECLARE cursor_name CURSOR [FOR | WITH] ...
OPEN CUR_VAR FOR sql_str;
OPEN cursor_name [USING var, ...];
FETCH cursor_name INTO var, ...;
CLOSE cursor_name;

Instruções SQL dinâmicas

A seguinte instrução do SQL dinâmico da Oracle e o equivalente do BigQuery:

Oracle	BigQuery
`EXECUTE IMMEDIATE sql_str [USING IN OUT [, ...]];`	`EXECUTE IMMEDIATE sql_expression [INTO variable[, ...]] [USING identifier[, ...]]; ;`

Instruções de fluxo de controle

A tabela a seguir mostra as instruções de fluxo de controle da Oracle e os equivalentes do BigQuery.

Oracle	BigQuery
`IF condition THEN [if_statement_list] [ELSE else_statement_list ] END IF;`	`IF condition THEN [if_statement_list] [ELSE else_statement_list ] END IF;`
`SET SERVEROUTPUT ON; DECLARE x INTEGER DEFAULT 0; y INTEGER DEFAULT 0; BEGIN LOOP IF x>= 10 THEN EXIT; ELSIF x>= 5 THEN y := 5; END IF; x := x + 1; END LOOP; dbms_output.put_line(x\|\|','\|\|y); END; /`	`DECLARE x INT64 DEFAULT 0; DECLARE y INT64 DEFAULT 0; LOOP IF x>= 10 THEN LEAVE; ELSE IF x>= 5 THEN SET y = 5; END IF; END IF; SET x = x + 1; END LOOP; SELECT x,y;`
`LOOP sql_statement_list END LOOP;`	`LOOP sql_statement_list END LOOP;`
`WHILE boolean_expression DO sql_statement_list END WHILE;`	`WHILE boolean_expression DO sql_statement_list END WHILE;`
`FOR LOOP`	`FOR LOOP` não é usado no BigQuery. Use outras instruções `LOOP`.
`BREAK`	`BREAK`
`CONTINUE`	`CONTINUE`
`CONTINUE/EXIT WHEN`	Use `CONTINUE` com a condição `IF`.
`GOTO`	A instrução `GOTO` não existe no BigQuery. Use a condição `IF`.

Instruções SQL de metadados e transações

Oracle	BigQuery
`GATHER_STATS_JOB`	Ainda não é usado no BigQuery.
`LOCK TABLE table_name IN [SHARE/EXCLUSIVE] MODE NOWAIT;`	Ainda não é usado no BigQuery.
`Alter session set isolation_level=serializable; /` `SET TRANSACTION ...`	O BigQuery sempre usa o isolamento de snapshot. Para ver detalhes, consulte Garantias de consistência e isolamento de transações neste documento.
`EXPLAIN PLAN ...`	Não usado no BigQuery. Recursos semelhantes são a explicação do plano de consulta na IU da Web do BigQuery e a alocação de slots e o registro de auditoria no Cloud Monitoring.
`SELECT * FROM DBA_[*];` (Visualizações da Oracle DBA_/ALL_/V$)	`SELECT * FROM mydataset.INFORMATION_SCHEMA.TABLES;` Para mais informações, consulte Introdução ao BigQuery INFORMATION_SCHEMA.
`SELECT * FROM GV$SESSION;` `SELECT * FROM V$ACTIVE_SESSION_HISTORY;`	O BigQuery não tem o conceito tradicional de sessão. É possível visualizar jobs de consulta na IU ou exportar registros de auditoria do Stackdriver para o BigQuery e analisar registros do BigQuery para analisar jobs. Para mais informações, consulte Ver detalhes do job.
`START TRANSACTION;` `LOCK TABLE table_A IN EXCLUSIVE MODE NOWAIT;` `DELETE FROM table_A;` `INSERT INTO table_A SELECT * FROM table_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 de consulta ou de cópia. Como usar uma consulta: `bq query --replace --destination_table table_A 'SELECT * FROM table_B';` Como usar uma cópia: `bq cp -f table_A table_B`

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

A Oracle 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.

Mensagens e códigos de erro

Os códigos de erro da Oracle e do BigQuery são diferentes. Se a lógica do aplicativo estiver detectando os erros, tente eliminar a origem do erro, porque o BigQuery não retorna os mesmos códigos de erro.

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

A Oracle 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 é atômica, mesmo com vários valores inseridos e atualizados.

Transações

A Oracle fornece níveis de isolamento de transação confirmados ou serializáveis. Os impasses são possíveis. Os jobs de inserção de anexo da Oracle são executados de maneira independente.

O BigQuery também tem suporte a transações. O BigQuery ajuda a garantir o controle de simultaneidade otimista (primeiro a confirmar) 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 instruções UPDATE na mesma tabela, o BigQuery muda para o controle de simultaneidade pessimista e para várias instruções UPDATE das filas. Elas são repetidas automaticamente em caso de conflitos. A Instrução DML INSERT e os jobs de carregamento podem ser executados de maneira simultânea e independente para anexar às tabelas.

Reversão

A Oracle é compatível com reversões. Como não há um limite explícito de transação no BigQuery, não há um conceito de reversão explícita no BigQuery. As soluções alternativas são decoradores de tabelas ou usar FOR SYSTEM_TIME AS OF.

Limites de bancos de dados

Verifique as cotas e os limites mais recentes do BigQuery. Muitas cotas para usuários de grandes volumes podem ser geradas entrando em contato com o Cloud Customer Care. A tabela a seguir mostra uma comparação dos limites do banco de dados da Oracle e do BigQuery.

Limite	Oracle	BigQuery
Tabelas por banco de dados	Irrestrito	Irrestrito
Colunas por tabela	1000	10.000
Tamanho máximo da linha	Ilimitado (depende do tipo de coluna)	100 MB
Tamanho do nome da coluna e da tabela	Se v12.2>= 128 bytes Outros 30 bytes	16.384 caracteres Unicode
Linhas por tabela	Ilimitado	Ilimitado
Tamanho máximo da solicitação SQL	Ilimitado	1 MB (tamanho máximo de consulta do GoogleSQL não resolvida) 12 MB (tamanho máximo de consulta legada e do GoogleSQL 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	Ilimitado	10 MB (solicitação) e 10 GB (resposta), ou praticamente ilimitado se você usar paginação ou a API Cloud Storage.
Número máximo de sessões simultâneas	Limitada pelos parâmetros de sessões ou processos	100 consultas simultâneas (podem ser geradas com uma reserva de slot), 300 solicitações de API simultâneas por usuário.
Número máximo de carregamentos simultâneos (rápidos)	Limitada pelos parâmetros de sessões ou processos	Nenhum limite de simultaneidade. Jobs estão na fila. 100.000 jobs de carregamento por projeto por dia.

Outros limites da Oracle Database incluem limites de tipo de dados, bancos de dados físicos, limites lógicos de bancos de dados e limites de processo e ambiente de execução.