Reglas de conversión en SQL estándar

"Conversión" incluye, entre otros, conversión de tipos y coerción.

La conversión de tipos es la conversión explícita y utiliza la función CAST().
La coerción es la conversión implícita, que realiza BigQuery automáticamente según las condiciones que se detallan a continuación.
Existe un tercer grupo de funciones de conversión con sus propios nombres de funciones, como UNIX_DATE().

En la tabla siguiente se resume todos los posibles CAST y posibilidades de coerción para los tipos de datos de BigQuery. "Coerción a" se aplica a todas las expresiones de un tipo de datos específico (p. ej., una columna), pero también se pueden forzar literales o parámetros. Consulta Coerción de literales y Coerción de parámetros para obtener más detalles.

De tipo	CONVERSIÓN a	Coerción a
INT64	BOOL INT64 NUMERIC FLOAT64 STRING	FLOAT64 NUMERIC
NUMERIC	INT64 NUMERIC FLOAT64 STRING	FLOAT64
FLOAT64	INT64 NUMERIC FLOAT64 STRING
BOOL	BOOL INT64 STRING
STRING	BOOL INT64 NUMERIC FLOAT64 STRING BYTES DATE DATETIME TIME TIMESTAMP
BYTES	BYTES STRING
DATE	DATE DATETIME STRING TIMESTAMP
DATETIME	DATE DATETIME STRING TIME TIMESTAMP
TIME	STRING TIME
TIMESTAMP	DATE DATETIME STRING TIME TIMESTAMP
ARRAY	ARRAY
STRUCT	STRUCT

Conversión de tipos

Sintaxis:

CAST(expr AS typename)

La sintaxis de conversión de tipos se usa en una consulta para indicar que el tipo de resultado de una expresión debe convertirse en algún otro tipo.

Ejemplo:

CAST(x=1 AS STRING)

Esto da como resultado "true" si x es 1, "false" para cualquier otro valor que no sea NULL y NULL si x es NULL.

Las conversiones entre tipos admitidos que no se mapean correctamente del valor original al dominio de destino producen errores en el entorno de ejecución. Por ejemplo, la conversión de BYTES a STRING cuando la secuencia de bytes no es un resultado UTF-8 válido devuelve un error en el entorno de ejecución.

Cuando se convierte una expresión x de los siguientes tipos, se aplican estas reglas:

De	A	Reglas cuando se convierte `x`
INT64	FLOAT64	Muestra un valor FLOAT64 cercano, pero potencialmente no exacto.
INT64	BOOL	Muestra `FALSE` si `x` es `0`; de lo contrario, `TRUE`.
NUMERIC	Floating Point	NUMERIC se convertirá al número de punto flotante más cercano con una pérdida de precisión posible.
FLOAT64	INT64	Muestra el valor INT64 más cercano. Los casos de punto medio, como 1.5 o -0.5 se redondean a cero.
FLOAT64	STRING	Muestra una representación aproximada de la string.
FLOAT64	NUMERIC	Si el número de punto flotante tiene más de nueve dígitos tras el punto decimal, se redondeará medio punto hacia arriba de cero. Convertir `NaN`, `+inf` o `-inf` hará que se muestre un error. Si se transmite un valor fuera del rango NUMERIC, se mostrará un error de desbordamiento.
BOOL	INT64	Se muestra `1` si `x` es `TRUE`, de lo contrario, `0`.
BOOL	STRING	Se muestra `"true"` si `x` es `TRUE`, de lo contrario, `"false"`.
STRING	FLOAT64	Muestra `x` como un valor FLOAT64 y se interpreta como que tiene la misma forma que un literal FLOAT64 válido. También es compatible con conversiones `"inf"`, `"+inf"`, `"-inf"` y `"nan"`. Las conversiones no distinguen entre mayúsculas y minúsculas.
STRING	NUMERIC	El literal numérico contenido en la `STRING` no debe exceder la precisión o el rango máximo del tipo `NUMERIC`; en caso contrario, ocurrirá un error. Si la cantidad de dígitos tras el punto decimal supera los nueve, entonces el valor `NUMERIC` resultante se redondeará medio punto hacia arriba de cero para que tenga diez dígitos tras el punto decimal.
STRING	BOOL	Muestra `TRUE` si `x` es `"true"` y `FALSE` si `x` es `"false"` Todos los demás valores de `x` no son válidos y arrojan un error en vez de transferir a BOOL. Las STRING no distinguen entre mayúsculas y minúsculas cuando se convierten en BOOL.
STRING	BYTES	Las STRING se convierten en BYTES mediante la codificación UTF-8. Por ejemplo, la STRING "©", cuando se la transforma en BYTES, se convierte en una secuencia de 2 bytes con valores hexadecimales C2 y A9.
BYTES	STRING	Muestra `x` interpretado como una STRING en UTF-8. Por ejemplo, el literal de BYTES `b'\xc2\xa9'`, cuando se transforma en STRING, se interpreta como UTF-8 y se convierte en el carácter unicode "©". Se produce un error si `x` no tiene formato UTF-8 válido.
ARRAY	ARRAY	Debe ser exactamente el mismo tipo de ARRAY.
STRUCT	STRUCT	Se permite si se cumplen las siguientes condiciones: Los dos STRUCT tienen la misma cantidad de campos. Los tipos de campo STRUCT original se pueden transmitir a los tipos de campos STRUCT de destino correspondientes (según se define por orden y no nombre de campo).

Conversión segura

Cuando usas CAST, la consulta puede fallar si BigQuery no puede realizar la conversión de tipos. Por ejemplo, la siguiente consulta genera un error:

SELECT CAST("apple" AS INT64) AS not_a_number;

Si deseas proteger tus consultas de estos tipos de errores, puedes usar SAFE_CAST. SAFE_CAST es idéntico a CAST, excepto que muestra NULL en vez de presentar un error.CAST

SELECT SAFE_CAST("apple" AS INT64) AS not_a_number;

+--------------+
| not_a_number |
+--------------+
| NULL         |
+--------------+

Si la conversión es de bytes a strings, también puedes utilizar la función SAFE_CONVERT_BYTES_TO_STRING. Los caracteres UTF-8 válidos se reemplazan con el carácter unicode de reemplazo, U+FFFD. Consulta SAFE_CONVERT_BYTES_TO_STRING para obtener más información.

Cómo convertir strings hexadecimales en números enteros

Si trabajas con strings hexadecimales (0x123), puedes convertirlas en números enteros:

SELECT '0x123' as hex_value, CAST('0x123' as INT64) as hex_to_int;

+-----------+------------+
| hex_value | hex_to_int |
+-----------+------------+
| 0x123     | 291        |
+-----------+------------+

SELECT '0x123' as hex_value, CAST('-0x123' as INT64) as hex_to_int;

+-----------+------------+
| hex_value | hex_to_int |
+-----------+------------+
| 0x123     | -291       |
+-----------+------------+

Conversión de tipos de fechas

BigQuery admite las conversiones de tipos de fechas hasta y desde strings como se muestra a continuación:

CAST(date_expression AS STRING)
CAST(string_expression AS DATE)

La conversión de un tipo de fecha a una string es independiente de la zona horaria y presenta la forma YYYY-MM-DD. Cuando se realiza una conversión de string a fecha, la string debe cumplir con el formato de fecha admitido y es independiente de la zona horaria. Se producirá un error si la expresión de la string no es válida o representa una fecha fuera al rango mínimo o máximo aceptado.

Conversión de tipos de marcas de tiempo

BigQuery admite la conversión de tipos de marcas de tiempo hasta y desde strings de la siguiente manera:

CAST(timestamp_expression AS STRING)
CAST(string_expression AS TIMESTAMP)

Cuando se realiza una conversión de tipos de marcas de tiempo a strings, la marca de tiempo se interpreta con la zona horaria predeterminada, UTC. La cantidad de dígitos de subsegundos producidos depende de la cantidad de ceros finales en la parte de subsegundos: la función CAST truncará cero, tres o seis dígitos.

Cuando se realiza una conversión de string a una marca de tiempo, string_expression debe cumplir con los formatos de marca de tiempo aceptados o, de lo contrario, ocurrirá un error en el entorno de ejecución. La string_expression podría contener una time_zone en sí misma; consulta las zonas horarias. Si hay una zona horaria en la string_expression, esta se utilizará para la conversión; en caso contrario, se usará la zona horaria predeterminada, UTC. Si la string tiene menos de seis dígitos, entonces se ensancha implícitamente.

Se produce un error si la string_expression no es válida, tiene más de seis dígitos de subsegundos (es decir, la precisión es superior a microsegundos) o representa un tiempo externo al rango de marca de tiempo aceptado.

Conversión entre tipos de fecha y marca de tiempo

BigQuery admite la conversión entre tipos de fecha y marca de tiempo de la siguiente manera:

CAST(date_expression AS TIMESTAMP)
CAST(timestamp_expression AS DATE)

La conversión de una fecha a una marca de tiempo interpreta date_expression a partir de la medianoche (inicio del día) en la zona horaria predeterminada, UTC. La conversión de una marca de tiempo a una fecha trunca efectivamente la marca de tiempo desde la zona horaria predeterminada.

Coerción

BigQuery fuerza el tipo de resultado de una expresión a otro tipo si necesita hacer coincidir las firmas de la función. Por ejemplo, si la función func() se define para que tenga un solo argumento del tipo INT64 y se usa una expresión como argumento que tiene un tipo de resultado de FLOAT64, entonces el resultado de la expresión se forzará al tipo INT64 antes de que se calcule la función func().

Coerción literal

BigQuery es compatible con los siguientes tipos de coerción literal:

Tipo de datos de entrada	Tipo de datos del resultado	Notas
Literal de STRING	DATE TIMESTAMP

La coerción literal es necesaria cuando el tipo literal real es diferente al tipo esperado por la función en cuestión. Por ejemplo, si la función func() tiene un argumento DATE, la expresión func("2014-09-27") es válida porque el literal de la STRING "2014-09-27" se fuerza a DATE.

La conversión literal se evalúa en el momento del análisis y genera un error si el literal de entrada no se puede convertir correctamente al tipo de destino.

Nota: Los literales de string no se fuerzan a tipos de números.

Coerción de parámetros

BigQuery admite las siguientes coerciones de parámetros:

Tipo de datos de entrada	Tipo de datos del resultado
Parámetro de la STRING

Aparecerá un error si el valor del parámetro no se puede forzar correctamente al tipo de destino.

Funciones de conversión adicionales

BigQuery proporciona las siguientes funciones de conversión adicionales:

¿Te ha resultado útil esta página? Enviar comentarios:

Except as otherwise noted, the content of this page is licensed under the Creative Commons Attribution 4.0 License, and code samples are licensed under the Apache 2.0 License. For details, see our Site Policies. Java is a registered trademark of Oracle and/or its affiliates.

Última actualización: Julio 16, 2019.