En esta página, se proporciona una descripción general de todos los tipos de datos de SQL estándar de Google, incluida la información sobre sus dominios de valor. 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:
Tipos de datos anulables
Para los tipos de datos anulables, NULL
es un valor válido. Por el momento, todos los tipos de datos existentes son anulables, pero se aplican condiciones para los ARRAY.
Tipos de datos ordenables
Las expresiones de tipos de datos ordenables se pueden usar en una cláusula ORDER BY
.
Se aplica a todos los tipos de datos, excepto a los siguientes:
ARRAY
STRUCT
GEOGRAPHY
JSON
Ordena valores NULL
En el contexto de la cláusula ORDER BY
, las NULL
son el valor mínimo posible. Es decir, las NULL
aparecen primero en las clasificaciones ASC
y últimas en las clasificaciones DESC
.
Los valores NULL
se pueden especificar como el primer o el último valor para una columna, sin importar ASC
o DESC
, mediante los modificadores NULLS FIRST
o NULLS LAST
, respectivamente.
Para obtener más información sobre el uso de ASC
, DESC
, NULLS FIRST
y NULLS LAST
, consulta la cláusula ORDER BY
.
Ordena puntos flotantes
Los valores de punto flotante se ordenan en este orden, de menor a mayor:
NULL
NaN
: Todos los valoresNaN
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
Tipos de datos agrupables
En general, los tipos de datos agrupables pueden aparecer en una expresión después de GROUP BY
, DISTINCT
y PARTITION BY
. Sin embargo, las expresiones PARTITION BY
no pueden incluir tipos de punto flotante. Se admiten todos los tipos de datos, excepto los siguientes:
GEOGRAPHY
JSON
ARRAY
STRUCT
Los valores especiales de punto flotante se agrupan de la siguiente manera, incluidos el agrupamiento realizado por una cláusula GROUP BY
y el agrupamiento realizado por la palabra clave DISTINCT
:
NULL
NaN
: Todos los valoresNaN
se consideran iguales para el agrupamiento.-inf
- 0 o -0: todos los valores cero se consideran iguales cuando se agrupa.
+inf
Tipos de datos comparables
Los valores del mismo tipo de datos comparables se pueden comparar entre sí. Se admiten todos los tipos de datos, excepto los siguientes:
GEOGRAPHY
JSON
Notas:
- Las comparaciones de igualdad para
STRUCT
se admiten campo por campo, en orden de campo. Los nombres de campo se ignoran. No se admiten las comparaciones menor que y mayor que. - Para comparar 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.
Tipos de datos que se pueden intercalar
Los tipos de datos que se pueden admitir admiten la intercalación, que determina cómo ordenar y comparar strings. Estos tipos de datos admiten la intercalación:
STRING
- Campos
STRING
en unSTRUCT
- Elementos
STRING
en unARRAY
El tamaño máximo del valor de una columna es de 10 MiB, que se aplica en los tipos escalares y de arreglo.
Tipos de datos con parámetros
Sintaxis:
DATA_TYPE(param[, ...])
Puedes usar parámetros a fin de especificar restricciones para los siguientes tipos de datos:
STRING
BYTES
NUMERIC
BIGNUMERIC
Un tipo de datos que se declara con parámetros se denomina tipo de datos con parámetros. Solo puedes usar tipos de datos con parámetros con columnas y variables de secuencia de comandos. Una columna con un tipo de datos con parámetros es una columna con parámetros, y una variable de secuencia de comandos con un tipo de datos con parámetros es una variable de secuencia de comandos con parámetros. Las restricciones de tipo con parámetros se aplican cuando se escribe un valor en una columna con parámetros o cuando se asigna un valor a una variable de secuencia de comandos con parámetros.
Los parámetros de un tipo de datos no se propagan en una expresión, solo el tipo de datos.
Ejemplos
-- Declare a variable with type parameters.
DECLARE x STRING(10);
-- This is a valid assignment to x.
SET x = "hello";
-- This assignment to x violates the type parameter constraint and results in an OUT_OF_RANGE error.
SET x = "this string is too long"
-- Declare variables with type parameters.
DECLARE x NUMERIC(10) DEFAULT 12345;
DECLARE y NUMERIC(5, 2) DEFAULT 123.45;
-- The variable x is treated as a NUMERIC value when read, so the result of this query
-- is a NUMERIC without type parameters.
SELECT x;
-- Type parameters are not propagated within expressions, so variables x and y are treated
-- as NUMERIC values when read and the result of this query is a NUMERIC without type parameters.
SELECT x + y;
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. Los elementos de un arreglo deben compartir el mismo tipo.
No se permiten 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
.
NULL y el tipo ARRAY
En la actualidad, BigQuery tiene las siguientes reglas con respecto a los NULL
y los ARRAY:
Un ARRAY puede ser
NULL
.Por ejemplo:
SELECT CAST(NULL AS ARRAY<INT64>) IS NULL AS array_is_null; +---------------+ | array_is_null | +---------------+ | TRUE | +---------------+
BigQuery traduce un ARRAY
NULL
en un ARRAY vacío en el resultado de la consulta, aunque dentro de la consulta,NULL
y los ARRAY vacíos sean dos valores distintos.Por ejemplo:
WITH Items AS ( SELECT [] AS numbers UNION ALL SELECT CAST(NULL AS ARRAY<INT64>)) SELECT numbers FROM Items; +---------+ | numbers | +---------+ | [] | | [] | +---------+
BigQuery genera un error si el resultado de la consulta tiene un ARRAY que contiene elementos
NULL
, aunque ese ARRAY se pueda usar dentro de la consulta.Por ejemplo, esto funciona:
SELECT FORMAT("%T", [1, NULL, 3]) as numbers; +--------------+ | numbers | +--------------+ | [1, NULL, 3] | +--------------+
Sin embargo, esto genera un error:
-- error SELECT [1, NULL, 3] as numbers;
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<BYTES(5)>
|
ARRAY simple de bytes con parámetros. |
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. |
Construye un ARRAY
Puedes construir un ARRAY mediante literales o funciones de array. Para aprender a hacerlo, consulta Trabaja con arrays.
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 usando UTF-8.
Tipo de bytes con parámetros
Tipo con parámetros | Descripción |
---|---|
BYTES(L) |
Secuencia de bytes con un máximo de L bytes permitidos en la string
binaria, en la que L es un valor INT64 positivo. Si una
secuencia de bytes tiene más de L bytes, se genera un
error OUT_OF_RANGE . |
Consulta Tipos de datos con parámetros para obtener más información sobre los tipos con parámetros y dónde se pueden usar.
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 |
De 0001-01-01 00:00:00 a 9999-12-31 23:59:59.999999 |
Un valor DATETIME representa una fecha y hora, como podrían aparecer en un reloj, y 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 separadorT
[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 los siguientes objetos:
- Geografía de punto: una sola ubicación en el espacio de coordenadas. Un punto tiene un valor de coordenada X y un valor de coordenada Y, en el que la coordenada x es la longitud y la coordenada y es la latitud del punto en el elipsoide de referencia WGS84.
- Geografía de una LineString: un objeto geométrico unidimensional, con una secuencia de puntos y bordes geodésicos entre ellos.
- Geografía del polígono: una superficie plana definida por 1 límite externo y 0 o más límites internos. Cada límite interno define un agujero en el polígono. Los bucles de límites de los polígonos están orientados para que, si atraviesas los vértices del límite en orden, el interior del polígono se encuentra a la izquierda.
Los puntos, las LineString y los polígonos de un
valor GEOGRAPHY
forman 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.
La GEOGRAPHY
que no contiene puntos, LineString
ni polígonos se denomina GEOGRAPHY
vacía.
GEOGRAPHY
es el resultado o un argumento de una función de Geografía.
Tipo de intervalo
Nombre | Rango |
---|---|
INTERVAL |
de -10000-0 -3660000 -87840000:0:0 a 10000-0 3660000 87840000:0:0 |
Un objeto INTERVAL representa la duración o la cantidad de tiempo. El intervalo consta de tres partes independientes:
[sign]Y-M
: Años y meses[sign]D
: Días[sign]H:M:S.F
: Horas, minutos, segundos y subsegundos
Formato canónico
[sign]Y-M [sign]D [sign]H:M:S[.F]
Y
: AñoM
: MesD
: DíaH
: HoraM
: MinutoS
: Segundo[.F]
: hasta seis dígitos fraccionarios (precisión de microsegundos)
Tipo JSON
Nombre | Descripción |
---|---|
JSON |
Representa JSON, un formato ligero de intercambio de datos. |
Espera estos comportamientos de canonicalización cuando crees un valor de tipo JSON
:
- Los valores booleanos, strings y valores nulos se conservan de forma exacta.
- No se conservan los caracteres de espacio en blanco.
- Un valor JSON puede almacenar números enteros en el rango de −9,223,372,036,854,775,808 (número entero de 64 bits con firma mínima), a 18,446,744,073,709,551,615 (número máximo de 64 bits sin firma dentro de un dominio de punto flotante)
FLOAT64
- El orden de los elementos de un array se conserva con exactitud.
- El orden de los miembros de un objeto no está garantizado ni se conserva.
- Si un objeto tiene claves duplicadas, la primera clave que se encuentra se conserva.
- Se pueden anidar hasta 500 niveles.
- Es posible que no se conserve el formato de la representación de string original de un número JSON.
Tipos numéricos
Los tipos numéricos incluyen los siguientes tipos:
INT64
con el aliasINT
,SMALLINT
,INTEGER
,BIGINT
,TINYINT
,BYTEINT
NUMERIC
con el aliasDECIMAL
BIGNUMERIC
con el aliasBIGDECIMAL
FLOAT64
Tipo número entero
Los números enteros son valores numéricos que no tienen componentes fraccionarios.
Nombre | Rango |
---|---|
INT64
INT
SMALLINT
INTEGER
BIGINT
TINYINT
BYTEINT
|
-9,223,372,036,854,775,808 a 9,223,372,036,854,775,807 |
INT
, SMALLINT
, INTEGER
, BIGINT
, TINYINT
y BYTEINT
son alias de INT64
.
Tipos de número decimal
Los valores de tipo decimal son valores numéricos con precisión y escala decimal 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 decimal con parámetros
Tipo con parámetros | Descripción |
---|---|
NUMERIC(P[,S])
DECIMAL(P[,S]) |
Un tipo NUMERIC o DECIMAL con una precisión máxima
de P y una escala máxima de S, en la que P y
S son tipos INT64 . S se interpreta como
0 si no se especifica.Rango de escala máximo: 0 ≤ S ≤ 9 Rango de precisión máximo: máx (1, S) ≤ P ≤ S + 29 |
BIGNUMERIC(P[, S])
BIGDECIMAL(P[, S]) |
Un tipo BIGNUMERIC o BIGDECIMAL con una precisión
máxima de P y una escala máxima de S, en la que
P y S son tipos INT64 . S se
interpreta como 0 si no se especifica.Rango de escala máximo: 0 ≤ S ≤ 38 Rango de precisión máximo: máx (1, S) ≤ P ≤ S + 38 |
Si un valor tiene más de S dígitos decimales, el valor se redondea a S dígitos decimales. Por ejemplo, si se inserta el valor 1.125 en una columna NUMERIC(5, 2), se redondea 1.125 parcialmente a 1.13.
Si un valor tiene más de P dígitos, genera un error OUT_OF_RANGE
.
Por ejemplo, si se inserta 1111 en una columna NUMERIC(5, 2), se muestra un error
OUT_OF_RANGE
, ya que 1111 es mayor que 999.99, el valor máximo permitido en una
columna NUMERIC(5, 2).
Consulta Tipos de datos con parámetros para obtener más información sobre los tipos con parámetros y dónde se pueden usar.
Tipo punto flotante
Los valores de punto flotante son valores numéricos aproximados con componentes fraccionarios.
Nombre | 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.
Los valores de punto flotante son aproximaciones.
- El formato binario que se usa para representar los valores de punto flotante solo puede representar un subconjunto de los números entre el número más positivo y el número más negativo en el rango de valores. Esto permite un control eficiente de un rango mucho más grande de lo que sería posible en caso contrario.
Los números que no son exactamente representables se aproximan mediante un valor cercano. Por ejemplo,
0.1
no se puede representar como un número entero escalado por una potencia de2
. Cuando este valor se muestra como una string, se redondea a una cantidad limitada de dígitos y el valor aproximado a0.1
puede aparecer como"0.1"
, lo que oculta el valor que no es preciso. En otras situaciones, la aproximación puede ser visible. - La suma de los valores de punto flotante puede producir resultados sorprendentes debido a la precisión limitada. Por ejemplo,
(1e30 + 1e-20) - 1e30 = 0
, mientras que(1e30 - 1e30) + 1e-20 = 1e-20
. Esto se debe a que el valor del punto flotante no tiene suficiente precisión para representar(1e30 + 1e-20)
, y el resultado se redondea a1e30
. En este ejemplo, también se muestra que el resultado de la función agregadaSUM
de los valores de puntos flotantes depende del orden en que se acumulan los valores. En general, este orden no es determinista y, por lo tanto, el resultado tampoco lo es. Por lo tanto, elSUM
resultante de los valores de punto flotante podría no ser determinista y dos ejecuciones de la misma consulta en las mismas tablas podrían producir resultados diferentes. - Si los puntos anteriores son preocupantes, usa un tipo decimal en su lugar.
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 |
Si quieres obtener más información sobre cómo se ordenan y agrupan estos valores para que se puedan comparar, consulta Ordena valores de punto flotante.
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 de string con parámetros
Tipo con parámetros | Descripción |
---|---|
STRING(L) |
String con un máximo de L caracteres Unicode permitidos en
la string, en la que L es un valor positivo INT64 . Si
se asigna una string con más de L caracteres Unicode, se genera un
error OUT_OF_RANGE . |
Consulta Tipos de datos con parámetros para obtener más información sobre los tipos con parámetros y dónde se pueden usar.
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 STRING(10)>
|
STRUCT simple con un solo campo de string con parámetros llamado x. |
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 yy 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 |
De 00:00:00 a 23:59:59.999999 |
Un valor TIME representa una hora del día, 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 valor 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.
Por lo general, TIMESTAMP se representa de forma interna como la cantidad de microsegundos transcurridos desde un momento inicial fijo.
Ten en cuenta que TIMESTAMP en sí no tiene una zona horaria. Representa el mismo instante en el tiempo a nivel global. Sin embargo, la visualización de una marca de tiempo para facilitar la lectura suele incluir una fecha, una hora y una zona horaria en un formato dependiente de la implementación. Por ejemplo, los valores mostrados “2020-01-01 00:00:00 UTC”, “2019-12-31 19:00:00 America/New_York” y “2020-01-01 05:30”: 00 Asia/Kolkata" representan el mismo instante en el tiempo y, por lo tanto, representan el mismo valor de TIMESTAMP.
- Para representar una fecha como podría aparecer en un calendario (una fecha civil), usa un valor de DATE.
- Para representar una hora como podría aparecer en un reloj (una hora civil), usa un valor de TIME.
- Para representar una fecha y hora como podrían aparecer en un reloj, usa un valor de DATETIME.
Formato canónico para literales de TIMESTAMP
El formato canónico de un literal de TIMESTAMP tiene las siguientes partes:
civil_date_time [time_zone]
civil_date_time:
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 separadorT
[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
Una zona horaria se usa cuando se convierte una fecha o una hora civil (como podría aparecer en un calendario o reloj) en una marca de tiempo (una hora absoluta) o viceversa. Esto incluye la operación de analizar una string que contiene una fecha y hora civil como “2020-01-01 00:00:00” y convertirla en una marca de tiempo. El valor de la marca de tiempo resultante no almacena una zona horaria específica, porque representa un instante en el tiempo a nivel global.
Las zonas horarias se representan con strings en uno de estos 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
Las siguientes marcas de tiempo son idénticas porque el desplazamiento de la zona horaria de America/Los_Angeles
es -08
en la fecha y hora especificadas.
SELECT UNIX_MILLIS(TIMESTAMP '2008-12-25 15:30:00 America/Los_Angeles') AS millis;
SELECT UNIX_MILLIS(TIMESTAMP '2008-12-25 15:30:00-08:00') AS millis;
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.