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

Guía de traducción de SQL de Oracle

En este documento se detallan las similitudes y las diferencias entre las sintaxis SQL de Oracle y BigQuery para ayudarte a planificar tu migración. Usa la traducción de SQL por lotes para migrar tus secuencias de comandos de SQL en bloque o la traducción de SQL interactiva para traducir consultas puntuales.

Tipos de datos

En esta sección se muestran las equivalencias entre los tipos de datos de Oracle y BigQuery.

Oracle	BigQuery	Notas
`VARCHAR2`	`STRING`
`NVARCHAR2`	`STRING`
`CHAR`	`STRING`
`NCHAR`	`STRING`
`CLOB`	`STRING`
`NCLOB`	`STRING`
`INTEGER`	`INT64`
`SHORTINTEGER`	`INT64`
`LONGINTEGER`	`INT64`
`NUMBER`	`NUMERIC`	BigQuery no permite que los usuarios especifiquen valores personalizados para la precisión o la escala. Por lo tanto, una columna de Oracle puede definirse de forma que tenga una escala mayor de la que admite BigQuery. Además, antes de almacenar un número decimal, Oracle lo redondea si tiene más dígitos después del decimal de los que se han especificado en la columna correspondiente. En BigQuery, esta función se puede implementar con la función `ROUND()`.
`NUMBER(*, x)`	`NUMERIC`	BigQuery no permite que los usuarios especifiquen valores personalizados para la precisión o la escala. Por lo tanto, una columna de Oracle puede definirse de forma que tenga una escala mayor de la que admite BigQuery. Además, antes de almacenar un número decimal, Oracle lo redondea si tiene más dígitos después del decimal de los que se han especificado en la columna correspondiente. En BigQuery, esta función se puede implementar con la función `ROUND()`.
`NUMBER(x, -y)`	`INT64`	Si un usuario intenta almacenar un número decimal, Oracle lo redondea al número entero más próximo. En BigQuery, si se intenta almacenar un número decimal en una columna definida como `INT64`, se produce un error. En este caso, se debe aplicar la función `ROUND()`. Los tipos de datos `INT64` de BigQuery permiten hasta 18 dígitos de precisión. Si un campo numérico tiene más de 18 dígitos, debe usarse el tipo de datos `FLOAT64` en BigQuery.
`NUMBER(x)`	`INT64`	Si un usuario intenta almacenar un número decimal, Oracle lo redondea al número entero más próximo. En BigQuery, si se intenta almacenar un número decimal en una columna definida como `INT64`, se produce un error. En este caso, se debe aplicar la función `ROUND()`. Los tipos de datos `INT64` de BigQuery permiten hasta 18 dígitos de precisión. Si un campo numérico tiene más de 18 dígitos, debe usarse el tipo de datos `FLOAT64` en BigQuery.
`FLOAT`	`FLOAT64`/`NUMERIC`	`FLOAT` es un tipo de datos exacto y un subtipo de `NUMBER` en Oracle. En BigQuery, `FLOAT64` es un tipo de datos aproximado. `NUMERIC` puede ser más adecuado para el tipo `FLOAT` en BigQuery.
`BINARY_DOUBLE`	`FLOAT64`/`NUMERIC`	`FLOAT` es un tipo de datos exacto y un subtipo de `NUMBER` en Oracle. En BigQuery, `FLOAT64` es un tipo de datos aproximado. `NUMERIC` puede ser más adecuado para el tipo `FLOAT` en BigQuery.
`BINARY_FLOAT`	`FLOAT64`/`NUMERIC`	`FLOAT` es un tipo de datos exacto y un subtipo de `NUMBER` en Oracle. En BigQuery, `FLOAT64` es un tipo de datos aproximado. `NUMERIC` puede ser más adecuado para el tipo `FLOAT` en BigQuery.
`LONG`	`BYTES`	El tipo de datos `LONG` se usa en versiones anteriores y no se recomienda en las nuevas versiones de Oracle Database. El tipo de datos `BYTES` de BigQuery se puede usar si es necesario almacenar datos `LONG` en BigQuery. Una mejor opción sería colocar objetos binarios en Cloud Storage y mantener referencias en BigQuery.
`BLOB`	`BYTES`	El tipo de datos `BYTES` se puede usar para almacenar datos binarios de longitud variable. Si este campo no se consulta ni se usa en las analíticas, es mejor almacenar los datos binarios en Cloud Storage.
`BFILE`	`STRING`	Los archivos binarios se pueden almacenar en Cloud Storage y se puede usar el tipo de datos `STRING` para hacer referencia a los archivos de una tabla de BigQuery.
`DATE`	`DATETIME`
`TIMESTAMP`	`TIMESTAMP`	BigQuery admite una precisión de microsegundos (10^-6), mientras que Oracle admite una precisión que va de 0 a 9. BigQuery admite el nombre de una región de zona horaria de una base de datos TZ y el desfase de zona horaria con respecto a UTC. En BigQuery, la conversión de la zona horaria debe realizarse manualmente para que coincida con la función `TIMESTAMP WITH LOCAL TIME ZONE` de Oracle.
`TIMESTAMP(x)`	`TIMESTAMP`	BigQuery admite una precisión de microsegundos (10^-6), mientras que Oracle admite una precisión que va de 0 a 9. BigQuery admite el nombre de una región de zona horaria de una base de datos TZ y el desfase de zona horaria con respecto a UTC. En BigQuery, la conversión de la zona horaria debe realizarse manualmente para que coincida con la función `TIMESTAMP WITH LOCAL TIME ZONE` de Oracle.
`TIMESTAMP WITH TIME ZONE`	`TIMESTAMP`	BigQuery admite una precisión de microsegundos (10^-6), mientras que Oracle admite una precisión que va de 0 a 9. BigQuery admite el nombre de una región de zona horaria de una base de datos TZ y el desfase de zona horaria con respecto a UTC. En BigQuery, la conversión de la zona horaria debe realizarse manualmente para que coincida con la función `TIMESTAMP WITH LOCAL TIME ZONE` de Oracle.
`TIMESTAMP WITH LOCAL TIME ZONE`	`TIMESTAMP`	BigQuery admite una precisión de microsegundos (10^-6), mientras que Oracle admite una precisión que va de 0 a 9. BigQuery admite el nombre de una región de zona horaria de una base de datos TZ y el desfase de zona horaria con respecto a UTC. En BigQuery, la conversión de la zona horaria debe realizarse manualmente para que coincida con la función `TIMESTAMP WITH LOCAL TIME ZONE` de Oracle.
`INTERVAL YEAR TO MONTH`	`STRING`	Los valores de intervalo se pueden almacenar como tipo de datos `STRING` en BigQuery.
`INTERVAL DAY TO SECOND`	`STRING`	Los valores de intervalo se pueden almacenar como tipo de datos `STRING` en BigQuery.
`RAW`	`BYTES`	El tipo de datos `BYTES` se puede usar para almacenar datos binarios de longitud variable. Si este campo no se consulta ni se usa en las analíticas, es mejor almacenar los datos binarios en Cloud Storage.
`LONG RAW`	`BYTES`	El tipo de datos `BYTES` se puede usar para almacenar datos binarios de longitud variable. Si este campo no se consulta ni se usa en las analíticas, es mejor almacenar los datos binarios en Cloud Storage.
`ROWID`	`STRING`	Oracle usa estos tipos de datos internamente para especificar direcciones únicas a las filas de una tabla. Por lo general, no se deben usar los campos `ROWID` ni `UROWID` en las aplicaciones. Sin embargo, si es así, se puede usar el tipo de datos `STRING` para almacenar estos datos.

Formato de tipo

Oracle SQL usa un conjunto de formatos predeterminados definidos como parámetros para mostrar expresiones y datos de columnas, así como para realizar conversiones entre tipos de datos. Por ejemplo, NLS_DATE_FORMAT se define como YYYY/MM/DD, que da formato a las fechas como YYYY/MM/DD de forma predeterminada. Puede consultar más información sobre los ajustes de NLS en la documentación online de Oracle. En BigQuery, no hay parámetros de inicialización.

De forma predeterminada, BigQuery espera que todos los datos de origen estén codificados en UTF-8 al cargarlos. Si tiene archivos CSV con datos codificados en formato ISO-8859-1, puede especificar explícitamente la codificación al importar los datos para que BigQuery pueda convertirlos correctamente a UTF-8 durante el proceso de importación.

Solo se pueden importar datos codificados en ISO-8859-1 o UTF-8. BigQuery almacena y devuelve los datos codificados en UTF-8. El formato de fecha o la zona horaria que se quiera usar se pueden definir en las funciones DATE y TIMESTAMP.

Formato de tipo de fecha y hora

Cuando convierta elementos de formato de marca de tiempo y de fecha de Oracle a BigQuery, debe tener en cuenta las diferencias de zona horaria entre TIMESTAMP y DATETIME, tal como se resume en la siguiente tabla.

Ten en cuenta que no hay paréntesis en los formatos de Oracle porque los formatos (CURRENT_*) son palabras clave, no funciones.

Oracle	BigQuery	Notas
`CURRENT_TIMESTAMP`	La información de `TIMESTAMP` en Oracle puede tener información de zona horaria diferente, que se define mediante `WITH TIME ZONE` en la definición de columna o en la variable `TIME_ZONE`.	Si es posible, usa la función `CURRENT_TIMESTAMP()`, que tiene el formato ISO. Sin embargo, el formato de salida siempre muestra la zona horaria UTC. (Internamente, BigQuery no tiene una zona horaria). Ten en cuenta los siguientes detalles sobre las diferencias en el formato ISO: `DATETIME` se formatea según las convenciones del canal de salida. En la herramienta de línea de comandos de BigQuery y en la consola de BigQuery, `DATETIME` se formatea con un separador `T` según RFC 3339. Sin embargo, en Python y Java JDBC, se usa un espacio como separador. Si quieres usar un formato explícito, usa la función `FORMAT_DATETIME`(), que convierte de forma explícita un valor en una cadena. Por ejemplo, la siguiente expresión siempre devuelve un espacio: `CAST(CURRENT_DATETIME() AS STRING)`
`CURRENT_DATE SYSDATE`	Oracle usa dos tipos de datos para las fechas: type 12 tipo 13 Oracle usa el tipo 12 al almacenar fechas. Internamente, se trata de números con una longitud fija. Oracle usa el tipo 13 cuando `SYSDATE or CURRENT_DATE` devuelve a.	BigQuery tiene un formato `DATE` independiente que siempre devuelve una fecha en formato ISO 8601. No se puede usar `DATE_FROM_UNIX_DATE` porque se basa en 1970.
`CURRENT_DATE-3`	Los valores de fecha se representan como números enteros. Oracle admite operadores aritméticos para los tipos de fecha.	En el caso de los tipos de fecha, usa `DATE_ADD`() o `DATE_SUB`(). BigQuery usa operadores aritméticos para los tipos de datos: `INT64`, `NUMERIC` y `FLOAT64`.
`NLS_DATE_FORMAT`	Define el formato de fecha de la sesión o del sistema.	BigQuery siempre usa ISO 8601, así que asegúrate de convertir las fechas y horas de Oracle.

Sintaxis de consulta

En esta sección se abordan las diferencias en la sintaxis de las consultas entre Oracle y BigQuery.

`SELECT` extractos

La mayoría de las instrucciones de Oracle SELECT son compatibles con BigQuery.

Funciones, operadores y expresiones

En las siguientes secciones se enumeran las asignaciones entre las funciones de Oracle y sus equivalentes en BigQuery.

Operadores de comparación

Los operadores de comparación de Oracle y BigQuery cumplen el estándar ANSI SQL:2011. Los operadores de comparación de la tabla siguiente son los mismos en BigQuery y en Oracle. Puedes usar REGEXP_CONTAINS en lugar de REGEXP_LIKE en BigQuery.

Operador	Descripción
`"="`	Igual
`<>`	No es igual
`!=`	No es igual
`>`	Mayor que
`>=`	Igual o mayor
`<`	Menos de
`<=`	Menor o igual
`IN ( )`	Coincide con un valor de una lista
`NOT`	Niega una condición
`BETWEEN`	Dentro de un intervalo (incluido)
`IS NULL`	`NULL` value
`IS NOT NULL`	No `NULL` value
`LIKE`	Coincidencia de patrones con %
`EXISTS`	La condición se cumple si la subconsulta devuelve al menos una fila

Los operadores de la tabla son los mismos tanto en BigQuery como en Oracle.

Expresiones y funciones 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)`

Funciones de agregación

En la siguiente tabla se muestran las asignaciones entre las funciones de agregación comunes, de agregación estadística y de agregación aproximada de Oracle con sus equivalentes en BigQuery:

Oracle	BigQuery
`ANY_VALUE` (desde 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))]` BigQuery no admite el resto de los argumentos que define 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`	Operador NOT bit a bit: ~
`BIT_OR`	`BIT_OR, X \| Y`
`BIT_XOR`	`BIT_XOR, X ^ Y`
`BITAND`	`BIT_AND, X & Y`
`CARDINALITY`	`COUNT`
`COLLECT`	BigQuery no admite `TYPE AS TABLE OF`. Considera la posibilidad de usar `STRING_AGG()` o `ARRAY_AGG()` en BigQuery
`CORR/CORR_K/` `CORR_S`	`CORR`
`COUNT`	`COUNT`
`COVAR_POP`	`COVAR_POP`
`COVAR_SAMP`	`COVAR_SAMP`
`FIRST`	No existe de forma implícita en BigQuery. Te recomendamos que uses funciones definidas por el usuario (UDF).
`GROUP_ID`	No se usa en BigQuery.
`GROUPING`	`GROUPING`
`GROUPING_ID`	No se usa en BigQuery.
`LAST`	No existe de forma implícita en BigQuery. Considera la posibilidad de usar funciones definidas por el usuario (UDF).
`LISTAGG`	`STRING_AGG, ARRAY_CONCAT_AGG(expression [ORDER BY key [{ASC\|DESC}] [, ... ]] [LIMIT n])`
`MAX`	`MAX`
`MIN`	`MIN`
`OLAP_CONDITION`	Específico de Oracle, no existe en BigQuery.
`OLAP_EXPRESSION`	Específico de Oracle, no existe en BigQuery.
`OLAP_EXPRESSION_BOOL`	Específico de Oracle, no existe en BigQuery.
`OLAP_EXPRESSION_DATE`	Específico de Oracle, no existe en BigQuery.
`OLAP_EXPRESSION_TEXT`	Específico de Oracle, no existe en BigQuery.
`OLAP_TABLE`	Específico de Oracle, no existe en BigQuery.
`POWERMULTISET`	Específico de Oracle, no existe en BigQuery.
`POWERMULTISET_BY_CARDINALITY`	Específico de Oracle, no existe en BigQuery.
`QUALIFY`	Específico de Oracle, no existe en 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`

BigQuery ofrece las siguientes funciones de agregación adicionales:

Funciones analíticas

En la siguiente tabla se muestran las asignaciones entre las funciones analíticas y de agregación analíticas de Oracle más habituales y sus equivalentes en BigQuery.

Oracle	BigQuery
`AVG`	`AVG`
`BIT_COMPLEMENT`	Operador NOT bit a bit: ~
`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`	No se admite en BigQuery. Usar una herramienta de BI o una función definida por el usuario personalizada
`CUME_DIST`	`CUME_DIST`
`DENSE_RANK(ANSI)`	`DENSE_RANK`
`FEATURE_COMPARE`	No existe de forma implícita en BigQuery. Considera la posibilidad de usar UDFs y BigQuery ML
`FEATURE_DETAILS`	No existe de forma implícita en BigQuery. Considera la posibilidad de usar UDFs y BigQuery ML
`FEATURE_ID`	No existe de forma implícita en BigQuery. Considera la posibilidad de usar UDFs y BigQuery ML
`FEATURE_SET`	No existe de forma implícita en BigQuery. Considera la posibilidad de usar UDFs y BigQuery ML
`FEATURE_VALUE`	No existe de forma implícita en BigQuery. Considera la posibilidad de usar UDFs y BigQuery ML
`FIRST_VALUE`	`FIRST_VALUE`
`HIER_CAPTION`	BigQuery no admite consultas jerárquicas.
`HIER_CHILD_COUNT`	BigQuery no admite consultas jerárquicas.
`HIER_COLUMN`	BigQuery no admite consultas jerárquicas.
`HIER_DEPTH`	BigQuery no admite consultas jerárquicas.
`HIER_DESCRIPTION`	BigQuery no admite consultas jerárquicas.
`HIER_HAS_CHILDREN`	BigQuery no admite consultas jerárquicas.
`HIER_LEVEL`	BigQuery no admite consultas jerárquicas.
`HIER_MEMBER_NAME`	BigQuery no admite consultas jerárquicas.
`HIER_ORDER`	BigQuery no admite consultas jerárquicas.
`HIER_UNIQUE_MEMBER_NAME`	BigQuery no admite consultas jerárquicas.
`LAST_VALUE`	`LAST_VALUE`
`LAG`	`LAG`
`LEAD`	`LEAD`
`LISTAGG`	`ARRAY_AGG STRING_AGG ARRAY_CONCAT_AGG`
`MATCH_NUMBER`	El reconocimiento y el cálculo de patrones se pueden realizar con expresiones regulares y FDU en BigQuery
`MATCH_RECOGNIZE`	El reconocimiento y el cálculo de patrones se pueden realizar con expresiones regulares y FDU en 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 de Oracle, no existe en BigQuery.
`PRESENTV`	Específico de Oracle, no existe en BigQuery.
`PREVIOUS`	Específico de Oracle, no existe en 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`	Se puede usar una función definida por el usuario.

Funciones de fecha y hora

En la siguiente tabla se muestran las asignaciones entre las funciones de fecha y hora de Oracle más habituales y sus equivalentes en BigQuery.

Oracle	BigQuery
`ADD_MONTHS(date, integer)`	`DATE_ADD(date, INTERVAL integer MONTH),` Si la fecha es un `TIMESTAMP`, puedes 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`	BigQuery no admite la zona horaria de la base de datos.
`EXTRACT`	`EXTRACT(DATE), EXTRACT(TIMESTAMP)`
`LAST_DAY`	`DATE_SUB( DATE_TRUNC( DATE_ADD( date_expression, INTERVAL 1 MONTH ), MONTH ), INTERVAL 1 DAY )`
`LOCALTIMESTAMP`	BigQuery no admite la configuración de zonas horarias.
`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`	No se admite en BigQuery. Considera la posibilidad de usar una función definida por el usuario personalizada.
`WM_CONTAINS` `WM_EQUALS` `WM_GREATERTHAN` `WM_INTERSECTION` `WM_LDIFF` `WM_LESSTHAN` `WM_MEETS` `WM_OVERLAPS` `WM_RDIFF`	En BigQuery no se usan puntos. Las funciones definidas por el usuario se pueden usar para comparar dos periodos.

BigQuery ofrece las siguientes funciones de fecha y hora adicionales:

Funciones de cadena

En la siguiente tabla se muestran las asignaciones entre las funciones de cadena de Oracle y sus equivalentes en BigQuery:

Oracle	BigQuery
`ASCII`	`TO_CODE_POINTS(string_expr)[OFFSET(0)]`
`ASCIISTR`	BigQuery no admite UTF-16
`RAWTOHEX`	`TO_HEX`
`LENGTH`	`CHAR_LENGTH`
`LENGTH`	`CHARACTER_LENGTH`
`CHR`	`CODE_POINTS_TO_STRING( [mod(numeric_expr, 256)] )`
`COLLATION`	No existe en BigQuery. BigQuery no admite COLLATE en DML
`COMPOSE`	Función personalizada definida por el usuario.
`CONCAT, (\|\| operator)`	`CONCAT`
`DECOMPOSE`	Función personalizada definida por el usuario.
`ESCAPE_REFERENCE (UTL_I18N)`	No se admite en BigQuery. Considera la posibilidad de usar una función definida por el usuario.
`INITCAP`	`INITCAP`
`INSTR/INSTR2/INSTR4/INSTRB/INSTRC`	Función personalizada definida por el usuario.
`LENGTH/LENGTH2/LENGTH4/LENGTHB/LENGTHC`	`LENGTH`
`LOWER`	`LOWER`
`LPAD`	`LPAD`
`LTRIM`	`LTRIM`
`NLS_INITCAP`	Función personalizada definida por el usuario.
`NLS_LOWER`	`LOWER`
`NLS_UPPER`	`UPPER`
`NLSSORT`	Específico de Oracle, no existe en BigQuery.
`POSITION`	`STRPOS(string, substring)`
`PRINTBLOBTOCLOB`	Específico de Oracle, no existe en BigQuery.
`REGEXP_COUNT`	`ARRAY_LENGTH(REGEXP_EXTRACT_ALL(value, regex))`
`REGEXP_INSTR`	`STRPOS(source_string, REGEXP_EXTRACT(source_string, regexp_string))` Nota: Devuelve la primera coincidencia.
`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`	No se admite en BigQuery. Considera la posibilidad de usar una 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 VERTICALES)	`CONCAT`

BigQuery ofrece las siguientes funciones de cadena adicionales:

Funciones matemáticas

En la siguiente tabla se muestran las asignaciones entre las funciones matemáticas de Oracle y sus equivalentes en 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`	Usar con `ISNULL`
`LOG`	`LOG`
`MOD (% operator)`	`MOD`
`POWER (** operator)`	`POWER, POW`
`DBMS_RANDOM.VALUE`	`RAND`
`RANDOMBYTES`	No se admite en BigQuery. Considera la posibilidad de usar una función definida por el usuario personalizada y la función RAND
`RANDOMINTEGER`	`CAST(FLOOR(10*RAND()) AS INT64)`
`RANDOMNUMBER`	No se admite en BigQuery. Considera la posibilidad de usar una función definida por el usuario personalizada y la función 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)`

BigQuery ofrece las siguientes funciones matemáticas adicionales:

Funciones de conversión de tipos

En la siguiente tabla se muestran las asignaciones entre las funciones de conversión de tipos de Oracle y sus equivalentes en 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`	No es necesario que sea específico de Oracle.
`CONVERT`	BigQuery no admite conjuntos de caracteres. Considera la opción de usar una función definida por el usuario personalizada.
`EMPTY_BLOB`	`BLOB` no se usa en BigQuery.
`EMPTY_CLOB`	`CLOB` no se usa en BigQuery.
`FROM_TZ`	BigQuery no admite los tipos con zonas horarias. Considera la posibilidad de usar una función definida por el usuario y FORMAT_TIMESTAMP
`INT_TO_BOOL`	`CAST`
`IS_BIT_SET`	No existe de forma implícita en BigQuery. Considera usar funciones definidas por el usuario
`NCHR`	Se puede usar una función definida por el usuario para obtener el equivalente de carácter de un valor binario.
`NUMTODSINTERVAL`	El tipo de datos `INTERVAL` no se admite en BigQuery
`NUMTOHEX`	No se admite en BigQuery. Usa una función definida por el usuario (UDF) personalizada y una función `TO_HEX`
`NUMTOHEX2`
`NUMTOYMINTERVAL`	El tipo de datos `INTERVAL` no se admite en BigQuery.
`RAW_TO_CHAR`	Específico de Oracle, no existe en BigQuery.
`RAW_TO_NCHAR`	Específico de Oracle, no existe en BigQuery.
`RAW_TO_VARCHAR2`	Específico de Oracle, no existe en BigQuery.
`RAWTOHEX`	Específico de Oracle, no existe en BigQuery.
`RAWTONHEX`	Específico de Oracle, no existe en BigQuery.
`RAWTONUM`	Específico de Oracle, no existe en BigQuery.
`RAWTONUM2`	Específico de Oracle, no existe en BigQuery.
`RAWTOREF`	Específico de Oracle, no existe en BigQuery.
`REFTOHEX`	Específico de Oracle, no existe en BigQuery.
`REFTORAW`	Específico de Oracle, no existe en BigQuery.
`ROWIDTOCHAR`	`ROWID` es un tipo específico de Oracle y no existe en BigQuery. Este valor debe representarse como una cadena.
`ROWIDTONCHAR`	`ROWID` es un tipo específico de Oracle y no existe en BigQuery. Este valor debe representarse como una cadena.
`SCN_TO_TIMESTAMP`	`SCN` es un tipo específico de Oracle y no existe en BigQuery. Este valor debe representarse como una marca de tiempo.
`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` La sintaxis de conversión se usa en una consulta para indicar que el tipo de resultado de una expresión debe convertirse en otro tipo.
`TREAT`	Específico de Oracle, no existe en BigQuery.
`VALIDATE_CONVERSION`	No se admite en BigQuery. Considera la posibilidad de usar una UDF personalizada
`VSIZE`	No se admite en BigQuery. Considera la posibilidad de usar una UDF personalizada

Funciones JSON

En la siguiente tabla se muestran las asignaciones entre las funciones JSON de Oracle y sus equivalentes en BigQuery.

Oracle	BigQuery
`AS_JSON`	`TO_JSON_STRING(value[, pretty_print])`
`JSON_ARRAY`	Considera la posibilidad de usar UDFs y la función `TO_JSON_STRING`
`JSON_ARRAYAGG`	Considera la posibilidad de usar UDFs y la función `TO_JSON_STRING`
`JSON_DATAGUIDE`	Función personalizada definida por el usuario.
`JSON_EQUAL`	Función personalizada definida por el usuario.
`JSON_EXIST`	Considera usar UDFs y `JSON_EXTRACT` o `JSON_EXTRACT_SCALAR`
`JSON_MERGEPATCH`	Función personalizada definida por el usuario.
`JSON_OBJECT`	No es compatible con BigQuery.
`JSON_OBJECTAGG`	No es compatible con BigQuery.
`JSON_QUERY`	Te recomendamos que uses funciones definidas por el usuario y `JSON_EXTRACT` o `JSON_EXTRACT_SCALAR`.
`JSON_TABLE`	Función personalizada definida por el usuario.
`JSON_TEXTCONTAINS`	Te recomendamos que uses funciones definidas por el usuario y `JSON_EXTRACT` o `JSON_EXTRACT_SCALAR`.
`JSON_VALUE`	`JSON_EXTRACT_SCALAR`

Funciones XML

BigQuery no proporciona funciones XML implícitas. El XML se puede cargar en BigQuery como cadena y se pueden usar funciones definidas por el usuario para analizar XML. También se puede procesar XML con una herramienta de extracción, transformación y carga (ETL) o de extracción, carga y transformación (ELT), como Dataflow. En la siguiente lista se muestran las funciones XML de Oracle:

Oracle	BigQuery
`DELETEXML`	Se pueden usar UDFs de BigQuery o una herramienta de ETL como Dataflow para procesar 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`

Funciones de aprendizaje automático

Las funciones de aprendizaje automático (ML) de Oracle y BigQuery son diferentes. Oracle requiere un paquete de analíticas avanzadas y licencias para aplicar el aprendizaje automático en la base de datos. Oracle usa el paquete DBMS_DATA_MINING para el aprendizaje automático. Para convertir trabajos de minería de datos de Oracle, es necesario reescribir el código. Puedes elegir entre las completas ofertas de productos de IA de Google, como BigQuery ML, las APIs de IA (incluidas Speech-to-Text, Text-to-Speech, Dialogflow, Cloud Translation, NLP, Cloud Vision y Timeseries Insights API), AutoML, AutoML Tables o AI Platform. Los cuadernos gestionados por el usuario de Google se pueden usar como entorno de desarrollo para los científicos de datos, y AI Platform Training de Google se puede usar para ejecutar cargas de trabajo de entrenamiento y puntuación a gran escala. En la siguiente tabla se muestran las funciones de Oracle ML:

Oracle	BigQuery
`CLASSIFIER`	Consulta BigQuery ML para ver las opciones de clasificación y regresión del aprendizaje automático.
`CLUSTER_DETAILS`
`CLUSTER_DISTANCE`
`CLUSTER_ID`
`CLUSTER_PROBABILITY`
`CLUSTER_SET`
`PREDICTION`
`PREDICTION_BOUNDS`
`PREDICTION_COST`
`PREDICTION_DETAILS`
`PREDICTION_PROBABILITY`
`PREDICTION_SET`

Funciones de seguridad

En la siguiente tabla se muestran las funciones para identificar al usuario en Oracle y BigQuery:

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

Funciones de conjunto o de matriz

En la siguiente tabla se muestran las funciones de conjuntos o arrays de Oracle y sus equivalentes en BigQuery:

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

Funciones de ventana

En la siguiente tabla se muestran las funciones de ventana de Oracle y sus equivalentes en BigQuery.

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

Consultas jerárquicas o recursivas

En BigQuery no se usan consultas jerárquicas ni recursivas. Si se conoce la profundidad de la jerarquía, se puede conseguir una función similar con las combinaciones, como se muestra en el siguiente ejemplo. Otra solución sería utilizar la API Storage de BigQuery y 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

En la siguiente tabla se muestran las funciones jerárquicas de Oracle.

Oracle	BigQuery
`DEPTH`	Las consultas jerárquicas no se usan en BigQuery.
`PATH`
`SYS_CONNECT_BY_PATH (hierarchical)`

Funciones UTL

UTL_File El paquete se usa principalmente para leer y escribir los archivos del sistema operativo desde PL/SQL. Cloud Storage se puede usar para cualquier tipo de archivo sin procesar. Las tablas externas y las operaciones de carga y exportación de BigQuery se deben usar para leer y escribir archivos desde y hacia Cloud Storage. Para obtener más información, consulta la introducción a las fuentes de datos externas.

Funciones espaciales

Puedes usar las analíticas geoespaciales de BigQuery para sustituir las funciones espaciales. En Oracle, hay SDO_* funciones y tipos, como SDO_GEOM_KEY, SDO_GEOM_MBR y SDO_GEOM_MMB. Estas funciones se usan para el análisis espacial. Puedes usar las analíticas geoespaciales para hacer análisis espaciales.

Sintaxis de DML

En esta sección se abordan las diferencias en la sintaxis del lenguaje de gestión de datos entre Oracle y BigQuery.

`INSERT` declaración

La mayoría de las instrucciones de Oracle INSERT son compatibles con BigQuery. En la tabla siguiente se muestran las excepciones.

Los scripts de DML de BigQuery tienen una semántica de coherencia ligeramente diferente a las instrucciones equivalentes de Oracle. Para obtener una descripción general del aislamiento de las copias de un momento dado y de la gestión de sesiones y transacciones, consulta la sección CREATE [UNIQUE] INDEX section de este documento.

Oracle BigQuery

Oracle	BigQuery
`INSERT INTO table VALUES (...);`	`INSERT INTO table (...) VALUES (...);` Oracle ofrece la palabra clave `DEFAULT` para las columnas no anulables. Nota: En BigQuery, omitir los nombres de las columnas en la instrucción `INSERT` solo funciona si se incluyen los valores de todas las columnas de la tabla de destino en orden ascendente según sus posiciones ordinales.
`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);` BigQuery impone cuotas de DML, que restringen el número de declaraciones de DML que puedes ejecutar al día. Para sacar el máximo partido de tu cuota, puedes seguir estos enfoques: Combina varias filas en una sola instrucción `INSERT`, en lugar de una fila por operación `INSERT`. Combina varias instrucciones de DML (incluida `INSERT`) mediante una instrucción `MERGE`. Usa `CREATE TABLE ... AS SELECT` para crear y rellenar tablas.

INSERT INTO table VALUES (...);

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

Oracle ofrece la palabra clave DEFAULT para las columnas no anulables.

Nota: En BigQuery, omitir los nombres de las columnas en la instrucción INSERT solo funciona si se incluyen los valores de todas las columnas de la tabla de destino en orden ascendente según sus posiciones ordinales.

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);

BigQuery impone cuotas de DML, que restringen el número de declaraciones de DML que puedes ejecutar al día. Para sacar el máximo partido de tu cuota, puedes seguir estos enfoques:

Combina varias filas en una sola instrucción INSERT, en lugar de una fila por operación INSERT.
Combina varias instrucciones de DML (incluida INSERT) mediante una instrucción MERGE.
Usa CREATE TABLE ... AS SELECT para crear y rellenar tablas.

`UPDATE` declaración

Las instrucciones UPDATE de Oracle son compatibles en su mayoría con BigQuery. Sin embargo, en BigQuery, la instrucción UPDATE debe tener una cláusula WHERE.

Como práctica recomendada, debes usar las instrucciones DML por lotes en lugar de varias instrucciones UPDATE y INSERT. Los scripts DML de BigQuery tienen una semántica de coherencia ligeramente diferente a las instrucciones equivalentes de Oracle. Para obtener una descripción general del aislamiento de las copias de seguridad y de la gestión de sesiones y transacciones, consulta la sección CREATE INDEX de este documento.

En la siguiente tabla se muestran las instrucciones de Oracle UPDATE y las instrucciones de BigQuery que realizan las mismas tareas.

En BigQuery, la instrucción UPDATE debe tener una cláusula WHERE. Para obtener más información sobre UPDATE en BigQuery, consulta los ejemplos de UPDATE de BigQuery en la documentación de DML.

`DELETE` y `TRUNCATE`

Las instrucciones DELETE y TRUNCATE son dos formas de eliminar filas de una tabla sin afectar al esquema de la tabla. TRUNCATE no se usa en BigQuery. Sin embargo, puede usar las instrucciones DELETE para conseguir el mismo efecto.

En BigQuery, la instrucción DELETE debe tener una cláusula WHERE. Para obtener más información sobre DELETE en BigQuery, consulta los ejemplos de DELETE de BigQuery en la documentación de DML.

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

`MERGE` declaración

La instrucción MERGE puede combinar operaciones INSERT, UPDATE y DELETE en una sola instrucción UPSERT y realizar las operaciones de forma atómica. La operación MERGE debe coincidir con una fila de origen como máximo por cada fila de destino. Tanto BigQuery como Oracle siguen la sintaxis ANSI.

Sin embargo, las secuencias de comandos DML de BigQuery tienen una semántica de coherencia ligeramente diferente a las instrucciones equivalentes de Oracle.

Sintaxis de DDL

En esta sección se abordan las diferencias en la sintaxis del lenguaje de definición de datos entre Oracle y BigQuery.

`CREATE TABLE` declaración

La mayoría de las instrucciones de CREATE TABLE de Oracle son compatibles con BigQuery, excepto las siguientes restricciones y elementos de sintaxis, que no se usan en BigQuery:

STORAGE
TABLESPACE
DEFAULT
GENERATED ALWAYS AS
ENCRYPT
PRIMARY KEY (col, ...). Para obtener más información, consulta CREATE INDEX.
UNIQUE INDEX. Para obtener más información, consulta CREATE INDEX.
CONSTRAINT..REFERENCES
DEFAULT
PARALLEL
COMPRESS

Para obtener más información sobre CREATE TABLE en BigQuery, consulta los ejemplos de CREATE TABLE de BigQuery.

Opciones y atributos de columna

Las columnas de identidad se introdujeron en la versión Oracle 12c, que permite el incremento automático de una columna. No se usa en BigQuery, sino que se puede conseguir con el siguiente método por lotes. Para obtener más información sobre las claves subrogadas y las dimensiones que cambian lentamente (SCD), consulta las siguientes guías:

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`

Comentarios de columna

Oracle usa la sintaxis Comment para añadir comentarios en las columnas. Esta función se puede implementar de forma similar en BigQuery usando la descripción de la columna, tal como se muestra en la siguiente tabla:

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

Tablas temporales

Oracle admite tablas temporales, que se suelen usar para almacenar resultados intermedios en secuencias de comandos. BigQuery admite tablas temporales.

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

Los siguientes elementos de Oracle no se usan en BigQuery:

ON COMMIT DELETE ROWS;
ON COMMIT PRESERVE ROWS;

También hay otras formas de emular tablas temporales en BigQuery:

Tiempo de vida del conjunto de datos: crea un conjunto de datos que tenga un tiempo de vida breve (por ejemplo, una hora) para que las tablas que se creen en él sean temporales (ya que no se conservarán más tiempo que el tiempo de vida del conjunto de datos). Puedes añadir el prefijo temp a todos los nombres de las tablas de este conjunto de datos para indicar claramente que las tablas son temporales.
TTL de tabla: crea una tabla que tenga un tiempo de vida breve específico de la tabla mediante declaraciones de DDL similares a las siguientes:
```
CREATE TABLE temp.name (col1, col2, ...)

OPTIONS(expiration_timestamp=TIMESTAMP_ADD(CURRENT_TIMESTAMP(), INTERVAL 1 HOUR));
```
Cláusula WITH: si solo se necesita una tabla temporal en el mismo bloque, usa un resultado temporal con una instrucción WITH o una subconsulta.

`CREATE SEQUENCE` declaración

Las secuencias no se usan en BigQuery. Esto se puede conseguir de la siguiente forma por lotes. Para obtener más información sobre las claves subrogadas y las dimensiones que cambian lentamente (SCD), consulte las siguientes guías:

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

`CREATE VIEW` declaración

En la siguiente tabla se muestran los equivalentes entre Oracle y BigQuery para la instrucción CREATE VIEW.

Oracle	BigQuery	Notas
`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 ...`
No compatible	`CREATE VIEW IF NOT EXISTS` `view_name` `OPTIONS(view_option_list)` `AS SELECT ...`	Crea una vista solo si no existe en el conjunto de datos especificado.

`CREATE MATERIALIZED VIEW` declaración

En BigQuery, las operaciones de actualización de vistas materializadas se realizan automáticamente. No es necesario especificar opciones de actualización (por ejemplo, al confirmar o según una programación) en BigQuery. Para obtener más información, consulta la introducción a las vistas materializadas.

Si la tabla base solo se modifica añadiendo datos, la consulta que usa la vista materializada (tanto si se hace referencia a la vista de forma explícita como si la selecciona el optimizador de consultas) analiza toda la vista materializada más un delta de la tabla base desde la última actualización de la vista. Esto significa que las consultas son más rápidas y económicas.

Por el contrario, si se han producido actualizaciones (DML UPDATE o MERGE) o eliminaciones (DML DELETE, truncamiento o vencimiento de particiones) en la tabla base desde la última actualización de la vista, la vista materializada no se analizará y, por lo tanto, la consulta no obtendrá ningún ahorro hasta la próxima actualización de la vista. Básicamente, cualquier actualización o eliminación en la tabla base invalida el estado de la vista materializada.

Además, los datos del búfer de streaming de la tabla base no se guardan en la vista materializada. El búfer de streaming se sigue analizando por completo, independientemente de si se usa la vista materializada.

En la siguiente tabla se muestran los equivalentes entre Oracle y BigQuery para la instrucción CREATE MATERIALIZED VIEW.

Oracle	BigQuery	Notas
`CREATE MATERIALIZED VIEW view_name REFRESH FAST NEXT sysdate + 7 AS SELECT … FROM TABLE_1`	`CREATE MATERIALIZED VIEW view_name AS SELECT ...`

`CREATE [UNIQUE] INDEX` declaración

En esta sección se describen los enfoques de BigQuery para crear funciones similares a los índices de Oracle.

Indexación para mejorar el rendimiento

BigQuery no necesita índices explícitos, ya que es una base de datos orientada a columnas con optimización de consultas y almacenamiento. BigQuery ofrece funciones como particiones y clústeres, así como campos anidados, que pueden aumentar la eficiencia y el rendimiento de las consultas optimizando la forma en que se almacenan los datos.

Indexación para la coherencia (UNIQUE, PRIMARY INDEX)

En Oracle, se puede usar un índice único para evitar filas con claves no únicas en una tabla. Si un proceso intenta insertar o actualizar datos que tienen un valor que ya está en el índice, la operación falla con una infracción del índice.

Como BigQuery no proporciona índices explícitos, se puede usar una instrucción MERGE para insertar solo registros únicos en una tabla de destino desde una tabla de almacenamiento provisional y descartar los registros duplicados. Sin embargo, no hay forma de evitar que un usuario con permisos de edición inserte un registro duplicado.

Para generar un error de registros duplicados en BigQuery, puedes usar una instrucción MERGE de la tabla de almacenamiento provisional, como se muestra en el siguiente ejemplo:

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());

En la mayoría de los casos, los usuarios prefieren eliminar los duplicados por su cuenta para encontrar errores en los sistemas posteriores.

BigQuery no admite columnas DEFAULT y IDENTITY (secuencias).

Bloqueo

BigQuery no tiene un mecanismo de bloqueo como Oracle y puede ejecutar consultas simultáneas (hasta tu cuota). Solo las instrucciones DML tienen ciertos límites de simultaneidad y, en algunos casos, pueden requerir un bloqueo de tabla durante la ejecución.

Declaraciones SQL procedimentales

En esta sección se describe cómo convertir las instrucciones de SQL procedimentales que se usan en procedimientos almacenados, funciones y activadores de Oracle a BigQuery.

`CREATE PROCEDURE` declaración

El procedimiento almacenado se admite como parte de la versión beta de secuencias de comandos de BigQuery.

Oracle	BigQuery	Notas
`CREATE PROCEDURE`	`CREATE PROCEDURE`	Al igual que Oracle, BigQuery admite `IN, OUT, INOUT` modos de argumentos. BigQuery no admite otras especificaciones de sintaxis.
`CREATE OR REPLACE PROCEDURE`	`CREATE OR REPLACE PROCEDURE`
`CALL`	`CALL`

En las siguientes secciones se describen formas de convertir instrucciones de procedimiento de Oracle en instrucciones de secuencias de comandos de BigQuery que tengan una funcionalidad similar.

`CREATE TRIGGER` declaración

Los activadores no se usan en BigQuery. La lógica de aplicación basada en filas debe gestionarse en la capa de aplicación. La función de activación se puede conseguir mediante la herramienta de ingestión, las funciones de Pub/Sub o Cloud Run durante el tiempo de ingestión, o bien mediante análisis periódicos.

Declaración y asignación de variables

En la siguiente tabla se muestran las instrucciones de Oracle DECLARE y sus equivalentes en 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;`

Declaraciones y operaciones de cursores

BigQuery no admite cursores, por lo que las siguientes instrucciones no se utilizan en 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;

Instrucciones SQL dinámicas

La siguiente instrucción de SQL dinámico de Oracle y su equivalente en BigQuery:

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

Instrucciones de flujo de control

En la siguiente tabla se muestran las instrucciones de flujo de control de Oracle y sus equivalentes en 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` no se usa en BigQuery. Usa otras instrucciones `LOOP`.
`BREAK`	`BREAK`
`CONTINUE`	`CONTINUE`
`CONTINUE/EXIT WHEN`	Usa la condición `CONTINUE` con `IF`.
`GOTO`	La instrucción `GOTO` no existe en BigQuery. Usa la condición `IF`.

Declaraciones SQL de metadatos y transacciones

Oracle	BigQuery
`GATHER_STATS_JOB`	Aún no se usa en BigQuery.
`LOCK TABLE table_name IN [SHARE/EXCLUSIVE] MODE NOWAIT;`	Aún no se usa en BigQuery.
`Alter session set isolation_level=serializable; /` `SET TRANSACTION ...`	BigQuery siempre usa el aislamiento de instantáneas. Para obtener más información, consulta el artículo Garantías de coherencia y aislamiento de transacciones de este documento.
`EXPLAIN PLAN ...`	No se usa en BigQuery. Las funciones similares son la explicación del plan de consulta en la interfaz web de BigQuery y la asignación de ranuras, así como el registro de auditoría en Stackdriver.
`SELECT * FROM DBA_[*];` (Vistas DBA_/ALL_/V$ de Oracle)	`SELECT * FROM mydataset.INFORMATION_SCHEMA.TABLES;` Para obtener más información, consulta Introducción a INFORMATION_SCHEMA de BigQuery.
`SELECT * FROM GV$SESSION;` `SELECT * FROM V$ACTIVE_SESSION_HISTORY;`	BigQuery no tiene el concepto tradicional de sesión. Puedes ver las tareas de consulta en la interfaz de usuario o exportar los registros de auditoría de Stackdriver a BigQuery y analizar los registros de BigQuery para analizar las tareas. Para obtener más información, consulta Ver los detalles de un trabajo.
`START TRANSACTION;` `LOCK TABLE table_A IN EXCLUSIVE MODE NOWAIT;` `DELETE FROM table_A;` `INSERT INTO table_A SELECT * FROM table_B;` `COMMIT;`	Sustituir el contenido de una tabla por el resultado de una consulta equivale a una transacción. Puedes hacerlo con una consulta o una operación de copia. Usar una consulta: `bq query --replace --destination_table table_A 'SELECT * FROM table_B';` Usar una copia: `bq cp -f table_A table_B`

Instrucciones SQL de varias líneas y con varias instrucciones

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

Códigos y mensajes de error

Los códigos de error de Oracle y los códigos de error de BigQuery son diferentes. Si la lógica de tu aplicación detecta los errores, intenta eliminar el origen del error, ya que BigQuery no devuelve los mismos códigos de error.

Garantías de coherencia y aislamiento de transacciones

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

Transacciones

Oracle proporciona niveles de aislamiento de transacciones de lectura confirmada o serializable. Es posible que se produzcan interbloqueos. Los trabajos de inserción de anexión de Oracle se ejecutan de forma independiente.

BigQuery también admite transacciones. BigQuery ayuda a garantizar el control de simultaneidad optimista (el primero en confirmar gana) con el aislamiento de instantáneas, en el que una consulta lee los últimos datos confirmados antes de que empiece. Este enfoque garantiza el mismo nivel de coherencia por fila y por mutación, así como entre las filas de la misma instrucción DML, pero evita los interbloqueos. En el caso de que haya varias instrucciones UPDATE en la misma tabla, BigQuery cambia al control de simultaneidad pesimista y pone en cola varias instrucciones UPDATE, y vuelve a intentarlo automáticamente en caso de conflicto. INSERT Las instrucciones DML y las tareas de carga se pueden ejecutar de forma simultánea e independiente para añadir datos a las tablas.

Restauración

Oracle admite reversiones. Como no hay ningún límite de transacción explícito en BigQuery, no existe el concepto de reversión explícita en BigQuery. Las soluciones alternativas son los decoradores de tabla o el uso de FOR SYSTEM_TIME AS OF.

Límites de las bases de datos

Consulta las cuotas y los límites más recientes de BigQuery. Muchas cuotas para usuarios con grandes volúmenes se pueden aumentar poniéndose en contacto con Cloud Customer Care. En la siguiente tabla se comparan los límites de las bases de datos de Oracle y BigQuery.

Límite	Oracle	BigQuery
Tablas por base de datos	Sin restricción	Sin restricción
Columnas por tabla	1000	10.000
Tamaño máximo de las filas	Ilimitado (depende del tipo de columna)	100 MB
Longitud del nombre de la columna y de la tabla	Si v12.2>= 128 bytes De lo contrario, 30 bytes	16.384 caracteres Unicode
Filas por tabla	Ilimitado	Ilimitado
Longitud máxima de las solicitudes de SQL	Ilimitado	1 MB (longitud máxima de las consultas de GoogleSQL sin resolver) 12 MB (longitud máxima de las consultas de SQL antiguo y de Google resueltas) Streaming: 10 MB (límite de tamaño de la solicitud HTTP) 10.000 (número máximo de filas por solicitud)
Tamaño máximo de solicitud y respuesta	Ilimitado	10 MB (solicitud) y 10 GB (respuesta), o prácticamente ilimitado si usas la paginación o la API de Cloud Storage.
Número máximo de sesiones simultáneas	Limitada por los parámetros de sesiones o procesos	100 consultas simultáneas (se puede aumentar con la reserva de espacios) y 300 solicitudes a la API simultáneas por usuario.
Número máximo de cargas (rápidas) simultáneas	Limitada por los parámetros de sesiones o procesos	No hay límite de simultaneidad; los trabajos se ponen en cola. 100.000 tareas de carga por proyecto y día.

Otros límites de Oracle Database incluyen los límites de tipos de datos, los límites de bases de datos físicas, los límites de bases de datos lógicas y los límites de procesos y de tiempo de ejecución.