Partilhar via

Regras de tipo de dados SQL

Aplica-se a:seleção marcada sim Databricks SQL seleção marcada sim Databricks Runtime

O Azure Databricks usa várias regras para resolver conflitos entre tipos de dados:

Você também pode converter explicitamente entre vários tipos.

  • a função cast realiza a conversão entre a maioria dos tipos e devolve erros se não conseguir.
  • função try_cast funciona como função cast mas devolve NULL quando passados valores inválidos.
  • Outras funções incorporadas são transmitidas entre tipos usando diretivas de formato fornecidas.

Promoção de tipo

A promoção de tipo é o processo de fundir um tipo em outro tipo da mesma família de tipos, que contém todos os valores possíveis do tipo original. Portanto, a promoção de tipo é uma operação segura. Por exemplo TINYINT , tem um intervalo de -128 até 127. Todos os seus valores possíveis podem ser promovidos de forma segura para INTEGER.

Lista de precedência de tipos

A lista de precedência de tipo define se os valores de um determinado tipo de dados podem ser implicitamente promovidos para outro tipo de dados.

Tipo de dados Lista de precedências (da mais estreita para a mais larga)
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) -> DUPLO
DECIMAL DECIMAL -> FLOAT (1) -> DUPLO
FLOAT FLOAT (1) -> DUPLO
DOUBLE DOUBLE
DATE DATA -> CARIMBO DE DATA/HORA
TIMESTAMP TIMESTAMP
ARRAY ARRAY (2)
BINARY BINARY
BOOLEAN BOOLEAN
INTERVAL INTERVAL
GEOGRAFIA GEOGRAFIA (QUALQUER)
GEOMETRIA GEOMETRIA (QUALQUER)
MAP MAPA (2)
STRING STRING
STRUCT ESTRUTURA (2)
VARIANT VARIANT
OBJECT OBJETO (3)

(1) Para resolução do tipo menos comumFLOAT é omitida para evitar perda de precisão.

(2) Para um tipo complexo, a regra de precedência aplica-se recursivamente aos seus elementos componentes.

(3)OBJECT existe apenas dentro de um VARIANT.

Strings e NULL

Aplicam-se regras especiais para STRING e não tipificadas NULL:

  • NULL pode ser promovido a qualquer outro tipo.
  • STRINGpode ser promovido a BIGINT, BINARY, BOOLEAN, DATE, DOUBLEINTERVAL, e TIMESTAMP. Se o valor real da cadeia de caracteres não puder ser convertido para o tipo menos comum, o Azure Databricks gerará um erro de tempo de execução. Ao promover para INTERVAL o valor da cadeia de caracteres deve corresponder às unidades de intervalo.

Gráfico de precedência de tipo

Esta é uma representação gráfica da hierarquia de precedência, combinando a lista de precedência de tipo e regras de cadeias de caracteres e NULLs.

Representação gráfica das regras de precedência

Resolução de tipo menos comum

O tipo menos comum de um conjunto de tipos é o tipo mais estreito alcançável a partir do gráfico de precedência de tipo por todos os elementos do conjunto de tipos.

A resolução de tipo menos comum é usada para:

  • Decida se uma função que espera um parâmetro de um determinado tipo pode ser invocada usando um argumento de um tipo mais restrito.
  • Derive o tipo de argumento para uma função que espera um tipo de argumento partilhado para múltiplos parâmetros, como coalesce, in, least ou greatest.
  • Derive os tipos de operando para os operadores, como operações aritméticas e comparações.
  • Derive o tipo de resultado para expressões como a expressão case.
  • Derive os tipos de elemento, chave ou valor para construtores de matrizes e mapas .
  • Derive o tipo de resultado dos operadores de conjunto UNION, INTERSECT ou EXCEPT em e.

Aplicam-se regras especiais se o tipo menos comum for resolvido para FLOAT. Se qualquer um dos tipos contribuintes for um tipo numérico exato (TINYINT, SMALLINT, INTEGER, BIGINT ou DECIMAL), o tipo menos comum é empurrado para DOUBLE para evitar a perda potencial de dígitos.

Quando o tipo menos comum é um STRING o agrupamento é calculado seguindo as regras de precedência de agrupamento .

Downcasting implícito e crosscasting

O Azure Databricks emprega essas formas de transmissão implícita somente na invocação de função e operador e somente quando puder determinar inequivocamente a intenção.

  • Downcasting implícito

    O downcasting implícito converte automaticamente um tipo mais amplo para um tipo mais estreito sem exigir que você especifique o elenco explicitamente. O downcasting é conveniente, mas acarreta o risco de erros de tempo de execução inesperados se o valor real não for representável no tipo estreito.

    O downcasting aplica a lista de precedência de tipo na ordem inversa. Os tipos de dados GEOGRAPHY e GEOMETRY nunca são convertidos.

  • Conversão implícita cruzada

    A conversão cruzada implícita converte um valor de uma família de tipos para outra sem que seja necessário especificar a conversão explicitamente.

    O Azure Databricks dá suporte à transmissão cruzada implícita de:

    • Qualquer tipo simples, exceto BINARY, GEOGRAPHY, e GEOMETRY, a STRING.
    • A STRING para qualquer tipo simples, exceto GEOGRAPHY e GEOMETRY.

Transmissão na invocação de função

Dada uma função ou operador resolvido, as seguintes regras se aplicam, na ordem em que são listadas, para cada parâmetro e par de argumentos:

  • Se um tipo de parâmetro com suporte fizer parte do gráfico de precedência de tipo do argumento, o Azure Databricks promoverá o argumento para esse tipo de parâmetro.

    Na maioria dos casos, a descrição da função indica explicitamente os tipos ou cadeias suportados, como "qualquer tipo numérico".

    Por exemplo, sin(expr) opera em DOUBLE mas aceita qualquer numérico.

  • Se o tipo de parâmetro esperado for a STRING e o argumento for um tipo simples, a Azure Databricks converte o argumento para o tipo de parâmetro de string.

    Por exemplo, substr(str, start, len) espera str ser um STRING. Em vez disso, pode passar um tipo numérico ou de data/hora.

  • Se o tipo de argumento for a STRING e o tipo de parâmetro esperado for simples, o Azure Databricks converte o argumento da cadeia para o tipo de parâmetro suportado mais amplo.

    Por exemplo, date_add(data, dias) espera um DATE e um INTEGER.

    Se invocar date_add() com dois STRINGs, o Azure Databricks crosscasta o primeiro STRING para DATE e o segundo STRING para um INTEGER.

  • Se a função esperar um tipo numérico, como um INTEGER ou tipo DATE, mas o argumento for de um tipo mais geral, como um DOUBLE ou TIMESTAMP, o Azure Databricks implicitamente converte o argumento para esse tipo de parâmetro.

    Por exemplo, um date_add(data, dias) espera um DATE e um INTEGER.

    Se invocar date_add() com um TIMESTAMP e um BIGINT, o Azure Databricks converte o TIMESTAMP para DATE, removendo o componente de tempo, e o BIGINT para um INTEGER.

  • Caso contrário, o Azure Databricks gerará um erro.

Examples

A coalesce função aceita qualquer conjunto de tipos de argumento, desde que compartilhem um tipo menos comum.

O tipo de resultado é o tipo menos comum dos 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)

A substring função espera argumentos do tipo STRING para a cadeia de caracteres e INTEGER para os parâmetros de início e comprimento.

-- 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 a conversão de tipo cruzada implícita para string.

-- 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 pode ser invocado com um TIMESTAMP ou BIGINT devido a downcasting implícito.

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

date_add pode ser invocado com STRINGs devido ao crosscasting implícito.

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