Tipos de datos en SQL estándar

BigQuery admite tipos de datos simples como números enteros, además de tipos más complejos como ARRAY y STRUCT. En esta página, se proporciona una descripción general de cada tipo de datos, incluidos los valores permitidos. Para obtener información sobre los literales de tipo de datos y constructores, consulta estructura léxica y sintaxis.

Propiedades de tipo de datos

Cuando se almacenan y consultan datos, es útil recordar las siguientes propiedades de tipo de datos:

Propiedad	Descripción	Se aplica a
Anulable	`NULL` es un valor válido.	Todos los tipos de datos, con las siguientes excepciones: Los ARRAY no pueden ser `NULL`. Los elementos de `NULL ARRAY` no pueden conservarse en una tabla.
Ordenable	Se puede usar en una cláusula `ORDER BY`.	Todos los tipos de datos, excepto los siguientes: ARRAY STRUCT GEOGRAPHY
Agrupable	En general, puede aparecer en una expresión después de `GROUP BY`, `DISTINCT` y `PARTITION BY`. Sin embargo, las expresiones `PARTITION BY` no pueden incluir los tipos de punto flotante.	Todos los tipos de datos, excepto los siguientes: ARRAY STRUCT GEOGRAPHY
Comparable	Los valores del mismo tipo se pueden comparar entre sí.	Todos los tipos de datos, con las siguientes excepciones: no se admiten las comparaciones ARRAY. Las comparaciones de igualdad para STRUCT se admiten campo por campo, en orden de campo. Los nombres de los campos se ignoran. No se admiten las comparaciones menor que y mayor que. No se admiten las comparaciones GEOGRAPHY. Para comparar los valores GEOGRAPHY, usa ST_Equals. Todos los tipos que admiten comparaciones se pueden usar en una condición `JOIN`. Consulta los tipos de JOIN para obtener una explicación sobre las condiciones de unión.

Tipo Array

Nombre	Descripción
`ARRAY`	Lista ordenada de cero o más elementos de cualquier tipo que no sea ARRAY.

Un ARRAY es una lista ordenada de cero o más elementos de valores que no son ARRAY. No se permiten arreglos ARRAY de varios ARRAY. Las consultas que podrían producir un ARRAY de varios ARRAY mostrarán un error. En su lugar, se debe insertar un STRUCT entre los ARRAY mediante la construcción SELECT AS STRUCT.

En la actualidad, BigQuery tiene dos limitaciones con respecto a los NULL y los ARRAY:

BigQuery genera un error si el resultado de la consulta tiene ARRAY que contienen elementos NULL, aunque tales ARRAY se puedan usar dentro de la consulta.
BigQuery traduce ARRAY NULL como ARRAY vacío en el resultado de la consulta, aunque dentro de la consulta NULL y de los ARRAY vacíos haya dos valores distintos.

Declara un tipo ARRAY

ARRAY<T>

Los tipos ARRAY se declaran mediante los corchetes angulares (< y >). El tipo de elementos de un ARRAY puede ser arbitrariamente complejo, con la excepción de que un ARRAY no puede contener de forma directa otro ARRAY.

Ejemplos

Declaración del tipo	Significado
`ARRAY<INT64>`	ARRAY simple de números enteros de 64 bits.
`ARRAY<STRUCT<INT64, INT64>>`	Un ARRAY de STRUCT, cada uno de los cuales contiene dos números enteros de 64 bits.
`ARRAY<ARRAY<INT64>>` (no admitido)	Esta es una declaración de tipo no válida que se incluye aquí en caso de que busques crear un ARRAY de múltiples niveles. Los ARRAY no pueden contener ARRAY directamente. En su lugar, consulta el siguiente ejemplo.
`ARRAY<STRUCT<ARRAY<INT64>>>`	Un ARRAY de varios ARRAY de números enteros de 64 bits. Observa que hay un STRUCT entre los dos ARRAY porque los ARRAY no pueden contener otros ARRAY directamente.

Tipo booleano

Nombre	Descripción
`BOOL`	Los valores booleanos están representados por las palabras clave `TRUE` y `FALSE` (no distinguen mayúsculas y minúsculas).

Los valores booleanos se ordenan en este orden, de menor a mayor:

NULL
FALSE
TRUE

Tipo bytes

Nombre	Descripción
`BYTES`	Datos binarios de longitud variable.

STRING y BYTES son tipos diferentes que no se pueden usar de forma indistinta. La mayoría de las funciones en STRING también se definen en BYTES. La versión BYTES opera en bytes sin procesar en lugar de caracteres Unicode. Las conversiones entre STRING y BYTES hacen que los bytes se codifiquen mediante UTF-8.

Tipo fecha

Nombre	Rango
`DATE`	0001-01-01 a 9999-12-31.

El tipo DATE representa una fecha lógica del calendario, independientemente de la zona horaria. Un valor DATE no representa un período específico de 24 horas. Más bien, un valor DATE dado representa un período diferente de 24 horas cuando se interpreta en diferentes zonas horarias. Este valor puede representar un día más corto o más largo durante las transiciones del horario de verano. Para representar un momento determinado absoluto, usa una marca de tiempo.

Formato canónico

'YYYY-[M]M-[D]D'

YYYY: Año de cuatro dígitos
[M]M: mes de uno o dos dígitos
[D]D: día de uno o dos dígitos

Tipo fecha y hora

Nombre	Rango
`DATETIME`	0001-01-01 00:00:00 a 9999-12-31 23:59:59.999999

Un objeto DATETIME representa una fecha y hora, como podrían aparecer en un calendario o reloj, que es independiente de la zona horaria. Incluye año, mes, día, hora, minuto, segundo y tiempo menor que un segundo. Para representar un momento determinado absoluto, usa una marca de tiempo.

Formato canónico

YYYY-[M]M-[D]D[( |T)[H]H:[M]M:[S]S[.F]]

YYYY: Año de cuatro dígitos
[M]M: mes de uno o dos dígitos
[D]D: día de uno o dos dígitos
( |T): un espacio o un separador “T”
[H]H: hora de uno o dos dígitos (valores válidos de 00 a 23)
[M]M: minutos de uno o dos dígitos (valores válidos de 00 a 59)
[S]S: segundos de uno o dos dígitos (valores válidos de 00 a 59)
[.F]: hasta seis dígitos fraccionarios (precisión de microsegundos)

Tipo geografía

Nombre	Descripción
`GEOGRAPHY`	Una colección de puntos, líneas y polígonos que se representa como un conjunto de puntos o un subconjunto de la superficie de la Tierra.

El tipo GEOGRAPHY se basa en la especificación de características simples (SFS) de OGC y es una colección de puntos, líneas o polígonos que forma una disposición “simple” en el elipsoide de referencia WGS84. Una disposición simple es aquella en la que ningún elemento de la colección contiene ningún punto en la superficie WGS84. Si hay intersecciones propias, se quitan de forma automática.

GEOGRAPHY es el resultado o un argumento de una función de Geografía.

Tipos numéricos

Los tipos numéricos incluyen los siguientes tipos:

INT64
NUMERIC con el alias DECIMAL
BIGNUMERIC con el alias BIGDECIMAL
FLOAT64

Tipo número entero

Los números enteros son valores numéricos que no tienen componentes fraccionarios.

Name	Rango
`INT64`	-9,223,372,036,854,775,808 a 9,223,372,036,854,775,807

Tipos de número decimal

Los valores de tipo decimal son valores numéricos con precisión y escala fijas. La precisión es el número de dígitos que contiene el número. La escala es cuántos de estos dígitos aparecen después del punto decimal.

Este tipo puede representar fracciones decimales exactamente y es adecuado para cálculos financieros.

Nombre	Precisión, escala y rango
`NUMERIC` `DECIMAL`	Precisión: 38 Escalamiento: 9 Mín.: -9.9999999999999999999999999999999999999E+28 Máx.: 9.9999999999999999999999999999999999999E+28
`BIGNUMERIC` `BIGDECIMAL`	Precisión: 76.76 (el 77.o dígitos es parcial) Escala: 38 Min: -5.7896044618658097711785492504343953926634992332820282019728792003956564819968E+38 Máx.: 5.7896044618658097711785492503953926349692332820282019728792003956564819967E+38

DECIMAL es un alias para NUMERIC. BIGDECIMAL es un alias para BIGNUMERIC.

Tipo punto flotante

Los valores de punto flotante son valores numéricos aproximados con componentes fraccionarios.

Name	Descripción
`FLOAT64`	Valores numéricos de precisión doble (aproximada).

Semántica de punto flotante

Cuando se trabaja con números de punto flotante, hay valores especiales no numéricos que se deben considerar: NaN y +/-inf

Los operadores aritméticos proporcionan el comportamiento IEEE-754 estándar a todos los valores de entrada finitos que producen salidas finitas y todas las operaciones para las cuales al menos una entrada es no finita.

Las llamadas de función y los operadores muestran un error de desbordamiento si la entrada es finita, pero la salida sería no finita. Si la entrada contiene valores no finitos, la salida puede ser no finita. En general, las funciones no ingresan NaN o +/-inf. Sin embargo, las funciones específicas como IEEE_DIVIDE pueden mostrar valores no finitos en entradas finitas. Todos estos casos se indican de manera explícita en las funciones matemáticas.

Ejemplos de funciones matemáticas

Término a la izquierda	Operador	Término a la derecha	Muestra
Cualquier valor	`+`	`NaN`	`NaN`
1.0	`+`	`+inf`	`+inf`
1.0	`+`	`-inf`	`-inf`
`-inf`	`+`	`+inf`	`NaN`
Valor `FLOAT64` máximo	`+`	Valor `FLOAT64` máximo	Error de desbordamiento
Valor `FLOAT64` mínimo	`/`	2.0	0.0
1.0	`/`	`0.0`	Error de división por cero

Los operadores de comparación proporcionan el comportamiento IEEE-754 estándar para la entrada de punto flotante.

Ejemplos de operadores de comparación

Término a la izquierda	Operador	Término a la derecha	Muestra
`NaN`	`=`	Cualquier valor	`FALSE`
`NaN`	`<`	Cualquier valor	`FALSE`
Cualquier valor	`<`	`NaN`	`FALSE`
-0.0	`=`	0.0	`TRUE`
-0.0	`<`	0.0	`FALSE`

Los valores de punto flotante se ordenan en este orden, de menor a mayor:

NULL
NaN: Todos los valores NaN se consideran iguales para el ordenamiento.
-inf
Números negativos
0 o -0: todos los valores cero se consideran iguales para el ordenamiento.
Números positivos
+inf

Los valores especiales de punto flotante se agrupan de esta manera, incluidos el agrupamiento realizado por una cláusula GROUP BY y el agrupamiento realizado por la palabra clave DISTINCT:

NULL
NaN: Todos los valores NaN se consideran iguales para el agrupamiento.
-inf
0 o -0: todos los valores cero se consideran iguales cuando se agrupa.
+inf

Tipo string

Nombre	Descripción
`STRING`	Datos de caracteres de longitud variable (Unicode).

Los valores STRING de entrada deben estar codificados en UTF-8 y los valores STRING de salida deben estar codificados en UTF-8. Las codificaciones alternativas como CESU-8 y UTF-8 modificada no se tratan como UTF-8 válidas.

Todas las funciones y operadores que actúan sobre los valores STRING operan en caracteres Unicode en lugar de bytes. Por ejemplo, las funciones como SUBSTR y LENGTH aplicadas a la entrada STRING cuentan el número de caracteres, no los bytes.

Cada carácter Unicode tiene un valor numérico denominado punto de código asignado. Los puntos de código más bajos se asignan a caracteres más bajos. Cuando se comparan los caracteres, los puntos de código determinan cuáles son los caracteres menores o mayores que otros.

La mayoría de las funciones en STRING también se definen en BYTES. La versión BYTES opera en bytes sin procesar en lugar de caracteres Unicode. STRING y BYTES son tipos diferentes que no se pueden usar de forma indistinta. No hay conversión de tipos implícita en ninguna dirección. La conversión de tipos explícita entre STRING y BYTES realiza la codificación y decodificación UTF-8. La conversión de tipos de BYTES a STRING muestra un error si los bytes no son UTF-8 válidos.

Tipo Struct

Nombre	Descripción
`STRUCT`	Contenedor de campos ordenados, cada uno con un tipo (obligatorio) y un nombre de campo (opcional).

Cómo declarar un tipo STRUCT

STRUCT<T>

Los tipos STRUCT se declaran mediante los corchetes angulares (< y >). El tipo de elementos de un STRUCT puede ser arbitrariamente complejo.

Ejemplos

Declaración del tipo	Significado
`STRUCT<INT64>`	STRUCT simple con un único campo de número entero de 64 bits sin nombre.
`STRUCT<x STRUCT<y INT64, z INT64>>`	Un STRUCT que contiene un STRUCT anidado llamado `x`. El STRUCT `x` tiene dos campos, `y` y `z`, que son números enteros de 64 bits.
`STRUCT<inner_array ARRAY<INT64>>`	Un STRUCT que contiene un ARRAY llamado `inner_array` que retiene números enteros de 64 bits.

Construye un STRUCT

Sintaxis de la tupla

(expr1, expr2 [, ... ])

El tipo de salida es un tipo STRUCT anónimo con campos anónimos con tipos que coinciden con los tipos de las expresiones de entrada. Debe haber al menos dos expresiones especificadas. De lo contrario, esta sintaxis es indistinguible de una expresión encerrada entre paréntesis.

Ejemplos

Sintaxis	Tipo de salida	Notas
`(x, x+y)`	`STRUCT<?,?>`	Si se usan nombres de columna (strings sin comillas), el tipo de datos del campo STRUCT se deriva del tipo de datos de la columna. `x` y`y` son columnas, por lo que los tipos de datos de los campos STRUCT se derivan de los tipos de columna y el tipo de salida del operador de suma.

Esta sintaxis también se puede usar con la comparación STRUCT para expresiones de comparación mediante claves de varias partes, p. ej., en una cláusula WHERE:

WHERE (Key1,Key2) IN ( (12,34), (56,78) )

Sintaxis de struct sin tipo

STRUCT( expr1 [AS field_name] [, ... ])

Se permiten nombres de campo duplicados. Los campos sin nombre se consideran campos anónimos y no se puede hacer referencia a ellos por nombre. Los valores de STRUCT pueden ser NULL o pueden tener valores de campo NULL.

Ejemplos

Sintaxis	Tipo de salida
`STRUCT(1,2,3)`	`STRUCT<int64,int64,int64>`
`STRUCT()`	`STRUCT<>`
`STRUCT('abc')`	`STRUCT<string>`
`STRUCT(1, t.str_col)`	`STRUCT<int64, str_col string>`
`STRUCT(1 AS a, 'abc' AS b)`	`STRUCT<a int64, b string>`
`STRUCT(str_col AS abc)`	`STRUCT<abc string>`

Sintaxis de struct escrita

STRUCT<[field_name] field_type, ...>( expr1 [, ... ])

La sintaxis escrita permite construir STRUCT con un tipo de datos STRUCT explícito. El tipo de salida es exactamente el field_type proporcionado. La expresión de entrada se coerciona a field_type si los dos tipos no son iguales y se genera un error si los tipos no son compatibles. AS alias no está permitido en las expresiones de entrada. El número de expresiones debe coincidir con el número de campos del tipo y los tipos de expresión deben ser coercibles o coercibles por literal para los tipos de campo.

Ejemplos

Sintaxis	Tipo de salida
`STRUCT<int64>(5)`	`STRUCT<int64>`
`STRUCT<date>("2011-05-05")`	`STRUCT<date>`
`STRUCT<x int64, y string>(1, t.str_col)`	`STRUCT<x int64, y string>`
`STRUCT<int64>(int_col)`	`STRUCT<int64>`
`STRUCT<x int64>(5 AS x)`	Error: la sintaxis escrita no permite `AS`

Comparaciones limitadas para STRUCT

Las STRUCT se pueden comparar directamente mediante operadores de igualdad:

Igual (=)
No es igual (!= o <>)
[NOT] IN

Sin embargo, ten en cuenta que estas comparaciones de igualdad directas cotejan los campos de STRUCT por pares en el orden ordinal, sin fijarse en los nombres de campo. Si, en cambio, deseas comparar campos con nombres idénticos de una STRUCT, puedes cotejar los campos individuales directamente.

Tipo hora

Nombre	Rango
`TIME`	00:00:00 a 23:59:59.99999

Un objeto TIME representa una hora, como podría aparecer en un reloj, y es independiente de una fecha y zona horaria específicas. Para representar un momento determinado absoluto, usa una marca de tiempo.

Formato canónico

[H]H:[M]M:[S]S[.DDDDDD|.F]

[H]H: hora de uno o dos dígitos (valores válidos de 00 a 23)
[M]M: minutos de uno o dos dígitos (valores válidos de 00 a 59)
[S]S: segundos de uno o dos dígitos (valores válidos de 00 a 59)
[.F]: hasta seis dígitos fraccionarios (precisión de microsegundos)

Tipo marca de tiempo

Nombre	Rango
`TIMESTAMP`	0001-01-01 00:00:00 a 9999-12-31 23:59:59.999999 UTC

Un objeto TIMESTAMP representa un momento determinado absoluto que es independiente de cualquier zona horaria o convención, como el horario de verano con precisión de microsegundos.

Para representar una fecha, como podría aparecer en un calendario, usa un objeto DATE.
Para representar una hora, como podría aparecer en un reloj, usa un objeto TIME.
Para representar una fecha y hora, como podría aparecer en un calendario y reloj, usa un objeto DATETIME.

Formato canónico

YYYY-[M]M-[D]D[( |T)[H]H:[M]M:[S]S[.F]][time zone]

YYYY: Año de cuatro dígitos
[M]M: mes de uno o dos dígitos
[D]D: día de uno o dos dígitos
( |T): un espacio o un separador “T”
[H]H: hora de uno o dos dígitos (valores válidos de 00 a 23)
[M]M: minutos de uno o dos dígitos (valores válidos de 00 a 59)
[S]S: segundos de uno o dos dígitos (valores válidos de 00 a 59)
[.F]: hasta seis dígitos fraccionarios (precisión de microsegundos)
[time zone]: string que representa la zona horaria Cuando una zona horaria no se especifica de forma explícita, se usa la zona horaria predeterminada, UTC. Consulta la sección de zonas horarias para obtener más detalles.

Zonas horarias

Las zonas horarias se usan cuando se analizan o se formatean las marcas de tiempo para fines de visualización. El valor de la marca de tiempo no almacena una zona horaria específica ni cambia cuando aplicas un desplazamiento de zona horaria.

Las zonas horarias se representan con strings en uno de estos dos formatos canónicos:

Desplazamiento del Horario Universal Coordinado (UTC) o la letra Z para UTC
Nombre de la zona horaria de la base de datos tz

Desplazamiento del Horario Universal Coordinado (UTC)

(+|-)H[H][:M[M]]
Z

Ejemplos

-08:00
-8:15
+3:00
+07:30
-7
Z

Cuando se usa este formato, no se permite ningún espacio entre la zona horaria y el resto de la marca de tiempo.

2014-09-27 12:30:00.45-8:00
2014-09-27T12:30:00.45Z

Nombre de zona horaria

continent/[region/]city

Los nombres de zonas horarias provienen de la base de datos tz. Si prefieres una referencia menos completa, pero más simple, consulta la lista de zonas horarias de la base de datos tz en Wikipedia.

Ejemplos

America/Los_Angeles
America/Argentina/Buenos_Aires

Cuando se usa un nombre de zona horaria, es obligatorio que haya un espacio entre el nombre y el resto de la marca de tiempo:

2014-09-27 12:30:00.45 America/Los_Angeles

Ten en cuenta que no todos los nombres de zona horaria son intercambiables, incluso si informan la misma hora durante una parte determinada del año. Por ejemplo, America/Los_Angeles representa la misma hora que UTC-7:00 durante el horario de verano, pero representa la misma hora que UTC-8:00 el resto del año.

Si no se especifica una zona horaria, se usa el valor predeterminado de la zona horaria.

Segundos bisiestos

Una marca de tiempo no es más que un desplazamiento de 1970-01-01 00:00:00 UTC, si se supone que hay exactamente 60 segundos por minuto. Los segundos bisiestos no se representan como parte de una marca de tiempo almacenada.

Si la entrada contiene valores que usan “:60” en el campo de segundos para representar un segundo bisiesto, ese segundo bisiesto no se conserva cuando se convierte en un valor de marca de tiempo. En su lugar, ese valor se interpreta como una marca de tiempo con “:00” en el campo de segundos del siguiente minuto.

Los segundos bisiestos no afectan los cálculos de marca de tiempo. Todos los cálculos de marca de tiempo se realizan mediante marcas de tiempo de estilo Unix, que no reflejan segundos bisiestos. Los segundos bisiestos solo son observables a través de funciones que miden el tiempo real. En estas funciones, es posible que un segundo de la marca de tiempo se omita o se repita cuando hay un segundo bisiesto.