Compartir a través de

Reglas de tipo de datos de SQL

Se aplica a:casilla marcada como Sí Databricks SQL casilla marcada como Sí Databricks Runtime

Azure Databricks usa varias reglas para resolver conflictos entre tipos de datos:

También puede convertir explícitamente entre muchos tipos:

Promoción de tipos

La promoción de tipos es el proceso de convertir un tipo en otro de la misma familia que contiene todos los valores posibles del original. Por lo tanto, la promoción de tipos es una operación segura. Por ejemplo, TINYINT tiene un rango de -128 a 127. Todos sus valores posibles se pueden promocionar de forma segura a INTEGER.

Lista de precedencia de tipos

La lista de precedencia de tipos define si los valores de un tipo de datos determinado se pueden promocionar implícitamente a otro tipo de datos.

Tipo de dato Lista de precedencia (de más limitado a más amplio)
TINYINT TINYINT -> SMALLINT -> INT -> BIGINT -> DECIMAL -> FLOAT (1) -> DOUBLE
SMALLINT SMALLINT -> INT -> BIGINT -> DECIMAL -> FLOAT (1) -> DOUBLE
INT INT -> BIGINT -> DECIMAL -> FLOAT (1) -> DOUBLE
BIGINT BIGINT - DECIMAL ->> FLOAT (1) -> DOUBLE
DECIMAL DECIMAL -> FLOAT (1) -> DOUBLE
FLOAT FLOAT (1):> DOUBLE
DOUBLE DOUBLE
DATE FECHA:> MARCA DE TIEMPO
TIMESTAMP TIMESTAMP
ARRAY MATRIZ (2)
BINARY BINARY
BOOLEAN BOOLEAN
INTERVAL INTERVAL
GEOGRAFÍA GEOGRAFÍA(CUALQUIERA)
GEOMETRÍA GEOMETRY(ANY)
MAP MAP (2)
STRING STRING
STRUCT STRUCT (2)
VARIANT VARIANT
OBJECT OBJECT (3)

(1) Se omite la resolución de tipos menos frecuentesFLOAT para evitar la pérdida de precisión.

(2) Para un tipo complejo, la regla de precedencia se aplica recursivamente a sus elementos componentes.

(3)OBJECT existe solo dentro de un VARIANT.

Cadenas y NULL

Se aplican reglas especiales a STRING y a NULL sin tipo:

  • NULL se puede promocionar a cualquier otro tipo.
  • STRING se puede promocionar a BIGINT, BINARY, BOOLEAN, DATE, DOUBLE, INTERVAL y TIMESTAMP. Si el valor de cadena real no se puede convertir al tipo menos común, Azure Databricks genera un error en tiempo de ejecución. Al promocionar a INTERVAL, el valor de cadena debe coincidir con las unidades de intervalo.

Gráfico de precedencia de tipos

Se trata de una representación gráfica de la jerarquía de precedencia, que combina la lista de precedencia de tipos y las reglas de cadenas y NULL.

Representación gráfica de las reglas de precedencia

Resolución de los tipos menos comunes

El tipo menos común de un conjunto de tipos es el más limitado al que pueden acceder todos los elementos del conjunto desde el gráfico de precedencia de tipos.

La resolución de tipos menos común se usa para:

  • Decidir si se puede invocar una función que espera un parámetro de un tipo determinado mediante un argumento de un tipo más limitado.
  • Derive el tipo de argumento de una función que espera un tipo de argumento compartido para varios parámetros, como coalesce, in, least o greatest.
  • Derivar los tipos de operando para operadores como operaciones aritméticas o comparaciones.
  • Derive el tipo de resultado para expresiones como la expresión case.
  • Derive los tipos de elemento, clave o valor para los constructores de matriz y mapa .
  • Derivar el tipo de resultado de los operadores de conjunto UNION, INTERSECT o EXCEPT.

Se aplican reglas especiales si el tipo menos común se resuelve en FLOAT. Si alguno de los tipos que contribuyen es un tipo numérico exacto (TINYINT, SMALLINT, INTEGER, BIGINTo DECIMAL), se inserta el tipo menos común en DOUBLE para evitar una posible pérdida de dígitos.

Cuando el tipo menos común es una STRING, la intercalación se calcula siguiendo las reglas de prioridad de intercalación.

Conversión a tipo heredado y cruzada implícitas

Azure Databricks emplea estas formas de conversión implícita solo en la invocación de función y operador y únicamente en aquellos casos en que se pueda determinar inequívocamente la intención.

  • Degradación implícita

    La conversión a tipo heredado implícita convierte automáticamente un tipo más amplio a otro más limitado sin necesidad de especificar la conversión de forma explícita. La conversión a tipo heredado es práctica, pero conlleva el riesgo de errores inesperados en tiempo de ejecución si el valor real no se puede representar en el tipo limitado.

    La conversión a tipo heredado aplica la lista de precedencia de tipos en orden inverso. Los tipos de datos GEOGRAPHY y GEOMETRY nunca se convierten a tipos heredados.

  • Difusión cruzada implícita

    La conversión cruzada implícita convierte un valor de una familia de tipos a otra sin necesidad de especificar explícitamente la conversión.

    Azure Databricks admite la conversión cruzada implícita en los siguientes casos:

    • Cualquier tipo simple, excepto BINARY, GEOGRAPHY, y GEOMETRY, a STRING.
    • Una STRING a cualquier tipo simple, excepto GEOGRAPHY y GEOMETRY.

Conversión al invocarse una función

Dada una función o un operador resueltos, se aplican las siguientes reglas, en el orden en que se enumeran, para cada par de parámetro y argumento:

  • Si un tipo de parámetro admitido forma parte del gráfico de precedencia de tipos del argumento, Azure Databricks promueve el argumento a ese tipo de parámetro.

    En la mayoría de los casos, la descripción de la función indica explícitamente los tipos o la cadenas que se admiten, como "cualquier tipo numérico".

    Por ejemplo, sin(expr) funciona en DOUBLE , pero aceptará cualquier valor numérico.

  • Si el tipo de parámetro esperado es un STRING y el argumento es un tipo simple, Azure Databricks convierte el argumento al tipo de parámetro de cadena.

    Por ejemplo, substr(str, start, len) espera que str sea STRING. En su lugar, puede pasar un tipo numérico o de fecha y hora.

  • Si el tipo de argumento es STRING y el tipo de parámetro esperado es un tipo simple, Azure Databricks realiza un crosscast del argumento de tipo cadena al tipo de parámetro más amplio admitido.

    Por ejemplo, date_add(fecha, días) espera un DATE y un INTEGER.

    Si invoca date_add() con dos STRINGs, Azure Databricks convierte el primero STRING en DATE y el segundo STRING en un INTEGER.

  • Si la función espera un tipo numérico, como un INTEGER o un tipo DATE, pero el argumento es un tipo más general, como un DOUBLE o TIMESTAMP, Azure Databricks convierte implícitamente el argumento a ese tipo de parámetro.

    Por ejemplo, un date_add(fecha, días) espera un DATE y un INTEGER.

    Si invoca date_add() con TIMESTAMP y BIGINT, Azure Databricks transforma el TIMESTAMP a DATE mediante la eliminación del componente de hora y el BIGINT a un INTEGER.

  • De lo contrario, Azure Databricks genera un error.

Examples

La coalesce función acepta cualquier conjunto de tipos de argumentos siempre que compartan un tipo menos común.

El tipo del resultado es el tipo menos común de los argumentos.

-- The least common type of TINYINT and BIGINT is BIGINT
> SELECT typeof(coalesce(1Y, 1L, NULL));
  BIGINT

-- INTEGER and DATE do not share a precedence chain or support crosscasting in either direction.
> SELECT typeof(coalesce(1, DATE'2020-01-01'));
  Error: DATATYPE_MISMATCH.DATA_DIFF_TYPES

-- Both are ARRAYs and the elements have a least common type
> SELECT typeof(coalesce(ARRAY(1Y), ARRAY(1L)))
  ARRAY<BIGINT>

-- The least common type of INT and FLOAT is DOUBLE
> SELECT typeof(coalesce(1, 1F))
  DOUBLE

> SELECT typeof(coalesce(1L, 1F))
  DOUBLE

> SELECT typeof(coalesce(1BD, 1F))
  DOUBLE

-- The least common type between an INT and STRING is BIGINT
> SELECT typeof(coalesce(5, '6'));
  BIGINT

-- The least common type is a BIGINT, but the value is not BIGINT.
> SELECT coalesce('6.1', 5);
  Error: CAST_INVALID_INPUT

-- The least common type between a DECIMAL and a STRING is a DOUBLE
>  SELECT typeof(coalesce(1BD, '6'));
  DOUBLE

-- Two distinct explicit collations result in an error
>  SELECT collation(coalesce('hello' COLLATE UTF8_BINARY,
                             'world' COLLATE UNICODE));
  Error: COLLATION_MISMATCH.EXPLICIT

-- The resulting collation between two distinct implicit collations is indeterminate
>  SELECT collation(coalesce(c1, c2))
     FROM VALUES('hello' COLLATE UTF8_BINARY,
                 'world' COLLATE UNICODE) AS T(c1, c2);
  NULL

-- The resulting collation between a explicit and an implicit collations is the explicit collation.
> SELECT collation(coalesce(c1 COLLATE UTF8_BINARY, c2))
    FROM VALUES('hello',
                'world' COLLATE UNICODE) AS T(c1, c2);
  UTF8_BINARY

-- The resulting collation between an implicit and the default collation is the implicit collation.
> SELECT collation(coalesce(c1, 'world'))
    FROM VALUES('hello' COLLATE UNICODE) AS T(c1, c2);
  UNICODE

-- The resulting collation between the default collation and the indeterminate collation is the default collation.
> SELECT collation(coalesce(coalesce('hello' COLLATE UTF8_BINARY, 'world' COLLATE UNICODE), 'world'));
  UTF8_BINARY

-- Least common type between GEOGRAPHY(srid) and GEOGRAPHY(ANY)
> SELECT typeof(coalesce(st_geogfromtext('POINT(1 2)'), to_geography('POINT(3 4)'), NULL));
  geography(any)

-- Least common type between GEOMETRY(srid1) and GEOMETRY(srid2)
> SELECT typeof(coalesce(st_geomfromtext('POINT(1 2)', 4326), st_geomfromtext('POINT(3 4)', 3857), NULL));
  geometry(any)

-- Least common type between GEOMETRY(srid1) and GEOMETRY(ANY)
> SELECT typeof(coalesce(st_geomfromtext('POINT(1 2)', 4326), to_geometry('POINT(3 4)'), NULL));
  geometry(any)

La substring función espera argumentos de tipo STRING para la cadena y INTEGER para los parámetros start y length.

-- Promotion of TINYINT to INTEGER
> SELECT substring('hello', 1Y, 2);
 he

-- No casting
> SELECT substring('hello', 1, 2);
 he

-- Casting of a literal string
> SELECT substring('hello', '1', 2);
 he

-- Downcasting of a BIGINT to an INT
> SELECT substring('hello', 1L, 2);
 he

-- Crosscasting from STRING to INTEGER
> SELECT substring('hello', str, 2)
  FROM VALUES(CAST('1' AS STRING)) AS T(str);
 he

-- Crosscasting from INTEGER to STRING
> SELECT substring(12345, 2, 2);
 23

|| (CONCAT) permite la difusión cruzada implícita a la cadena.

-- A numeric is cast to STRING
> SELECT 'This is a numeric: ' || 5.4E10;
 This is a numeric: 5.4E10

-- A date is cast to STRING
> SELECT 'This is a date: ' || DATE'2021-11-30';
 This is a date: 2021-11-30

date_add se puede invocar con TIMESTAMP o BIGINT debido a la degradación implícita.

> SELECT date_add(TIMESTAMP'2011-11-30 08:30:00', 5L);
 2011-12-05

date_add se puede invocar con STRINGs debido a la difusión cruzada implícita.

> SELECT date_add('2011-11-30 08:30:00', '5');
  2011-12-05
  • Last updated on