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 una conversión explícita y usa la función CAST().
La coerción es la conversión implícita, que realiza BigQuery de forma automática 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 siguiente tabla, se resumen todas las posibilidades de coerción y CAST para los tipos de datos de BigQuery. “Coerción a” se aplica a todas las expresiones de un tipo de datos determinado (p. ej., una columna), pero los literales y los parámetros también se pueden coercionar. Consulta la sección sobre 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 con éxito 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 el tipo de una expresión x de los siguientes tipos, se aplican estas reglas:

De	A	Reglas para la conversión de tipos de `x`
INT64	FLOAT64	Muestra un valor FLOAT64 cercano, pero potencialmente no exacto.
INT64	BOOL	Muestra `FALSE` si `x` es `0`, y `TRUE` en caso contrario.
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 en dirección opuesta al 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. Si conviertes el tipo de un `NaN`, `+inf` o `-inf`, se mostrará un error. Si se convierte el tipo de un valor fuera del rango de `NUMERIC`, se mostrará un error de desbordamiento.
BOOL	INT64	Muestra `1` si `x` es `TRUE`, y `0` en caso contrario.
BOOL	STRING	Muestra `"true"` si `x` es `TRUE`, y `"false"` en caso contrario.
STRING	FLOAT64	Muestra `x` como un valor FLOAT64 y lo interpreta como si tuviera el mismo formato que un literal FLOAT64 válido. También admite conversiones de tipo desde `"inf"`, `"+inf"`, `"-inf"` y `"nan"`. Las conversiones no distinguen entre mayúsculas y minúsculas.
STRING	NUMERIC	El literal numérico incluido en `STRING` no debe exceder la precisión o rango máximo del tipo `NUMERIC`. De lo contrario, se producirá un error. Si la cantidad de dígitos tras el punto decimal es mayor que nueve, el valor `NUMERIC` resultante se redondeará con los valores medios en dirección opuesta al cero para que tenga nueve 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 muestran un error en lugar de convertir el tipo en 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 UTF-8. Por ejemplo, el literal de BYTES `b'\xc2\xa9'`, cuando se convierte su tipo en STRING, se interpreta como UTF-8 y se convierte en el carácter Unicode “©”. Se produce un error si `x` no es un valor de 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, pero muestra NULL en vez de generar un error.

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

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

Si conviertes el tipo de bytes en strings, también puedes usar la función SAFE_CONVERT_BYTES_TO_STRING. Los caracteres UTF-8 no válidos se reemplazan por el carácter de reemplazo de Unicode, 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 convertir sus tipos 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 desde y hacia 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 tiene 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 del 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 desde y hacia strings de la siguiente manera:

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

Cuando se realiza una conversión de tipos de marca de tiempo a string, 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 tipo de string a marca de tiempo, string_expression debe cumplir con los formatos de literal de marca de tiempo aceptados o, de lo contrario, ocurrirá un error en el entorno de ejecución. string_expression puede contener un time_zone; consulta zonas horarias. Si hay una zona horaria en string_expression, se usa para la conversión; de lo contrario, se usa la zona horaria predeterminada, UTC. Si la string tiene menos de seis dígitos, entonces se ensancha de forma implícita.

Se produce un error si 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 de forma efectiva la marca de tiempo desde la zona horaria predeterminada.

Coerción

BigQuery coerciona 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 coercionará 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 que espera la función en cuestión. Por ejemplo, si la función func() toma un argumento DATE, la expresión func("2014-09-27") es válida porque el literal de STRING "2014-09-27" se coerciona 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 con éxito al tipo de destino.

Nota: Los literales de string no se coercionan 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: