"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 resumen todos los posibles CAST
y las 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 convertir literales o parámetros. 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 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áximos del tipo NUMERIC , ya que generaría un error. Si la cantidad de dígitos tras el punto decimal es mayor que nueve, el valor NUMERIC resultante se redondeará lejos de 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 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:
|
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 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 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: