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 de consulta

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_expr*dep_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
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 ...
Sem suporte 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 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:

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.

Reverter

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.