Compartilhar via

Regras de tipo de dados SQL

  • Artigo

Aplica-se a:marca de seleção positiva SQL do Databricks marca de seleção positiva Runtime do Databricks

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

Você também pode converter explicitamente entre muitos tipos:

Promoção de tipos

Promoção de tipos é o processo de conversão de 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 tipos é uma operação segura. Por exemplo, TINYINT tem um intervalo de -128 a 127. Todos os seus valores possíveis podem ser promovidos com segurança para INTEGER.

Lista de precedência de tipos

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

Tipo de dados Lista de precedência (da mais restrita para a mais ampla)
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 DATE -> TIMESTAMP
TIMESTAMP timestamp
ARRAY ARRAY (2)
BINARY BINARY
BOOLIANO BOOLEAN
INTERVAL INTERVAL
MAP MAP (2)
STRING STRING
STRUCT STRUCT (2)
VARIANT VARIANT
OBJECT OBJECT (3)

(1) Para resolução de tipo menos comum, FLOAT é ignorado para evitar a perda de precisão.

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

(3)OBJECT existe somente dentro de um VARIANT.

Cadeias de caracteres e NULL

Regras especiais se aplicam a STRING e NULL não digitado:

  • NULL pode ser promovido a qualquer outro tipo.
  • STRING pode ser promovido a BIGINT, BINARY, BOOLEAN, DATE, DOUBLE, INTERVAL e TIMESTAMP. Se o valor real da cadeia de caracteres não puder ser convertido em um tipo mínimo 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 intervalos.

Grafo de precedência de tipos

Essa é uma representação gráfica da hierarquia de precedência, combinando a lista de precedência de tipos e as regras de cadeia de caracteres e NULLs.

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

Resolução de tipo mínimo comum

O tipo mínimo comum em um conjunto de tipos é o mais restrito do grafo de precedência de tipos acessível por todos os elementos do conjunto de tipos.

A resolução de tipo mínimo comum é usada para:

  • Decidir se uma função que espera um parâmetro de determinado tipo pode ser chamada com o uso de um argumento de um tipo mais restrito.
  • Derivar o tipo de argumento para uma função que espera um tipo de argumento compartilhado para vários parâmetros, como coalesce, in,leastou greatest.
  • Derivar os tipos de operando para operadores como operações aritméticas ou comparações.
  • Derivar o tipo de resultado para expressões como a expressão CASE.
  • Derivar os tipos de elemento, chave ou valor para construtores array e map.
  • Derivar o tipo de resultado dos operadores de conjunto UNION, INTERSECT ou EXCEPT.

Regras especiais serão aplicadas se o tipo mínimo 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 mínimo comum será enviado por push para DOUBLE para evitar uma possível perda de dígitos.

Quando o tipo menos comum é um STRING a ordenação é computada seguindo as regras de precedência de ordenação .

Downcasting e crosscasting implícitos

O Azure Databricks emprega essas formas de conversão implícita somente em invocação de função e de operador, e apenas onde ela pode determinar a intenção de forma não ambígua.

  • Downcasting implícito

    O downcasting implícito converte automaticamente um tipo mais amplo em outro mais restrito, sem exigir a especificação explícita da conversão. O downcasting é conveniente, mas implica risco de erros de tempo de execução inesperados se o valor real não puder ser representável no tipo limitado.

    O downcasting aplica a lista de precedência de tipo na ordem inversa.

  • Crosscasting implícito

    O crosscasting implícito converte um valor de uma família de tipos em outro, sem exigir que você especifique a conversão explicitamente.

    O Azure Databricks oferece suporte a crosscasting implícito de:

    • Qualquer tipo simples, exceto BINARY, para STRING.
    • Uma STRING para qualquer tipo simples.

Casting na invocação de função

Dada uma função ou um operador resolvido, as regras a seguir se aplicam, na ordem em que estão listadas, a cada parâmetro e par de argumentos:

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

    Na maioria dos casos, a descrição da função declara explicitamente os tipos ou a cadeia com suporte, como "qualquer tipo numérico".

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

  • Se o tipo de parâmetro esperado for STRING a e o argumento for um tipo simples, o Azure Databricks executará crosscast do argumento para o tipo de parâmetro da cadeia de caracteres.

    Por exemplo, substr(str, start, len) espera que str seja uma STRING. Em vez disso, você pode transmitir um tipo numérico ou de data e hora.

  • Se o tipo de argumento esperado for STRING e o parâmetro for do tipo simples, o Azure Databricks executará crosscast do argumento da cadeia de caracteres para tipo de parâmetro mais amplo com suporte.

    Por exemplo, date_add(date, days) espera uma DATE e um INTEGER.

    Se você invocar date_add() com dois STRINGs, o Azure Databricks executará crosscast do primeiro STRING para DATE e do segundo STRING para INTEGER.

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

    Por exemplo, date_add(date, days) espera uma DATE e um INTEGER.

    Se você invocar date_add() com TIMESTAMP e BIGINT, o Azure Databricks executará downcast de TIMESTAMP para DATE removendo o componente de hora, e de BIGINT para INTEGER.

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

Exemplos

A função coalesce aceita qualquer conjunto de tipos de argumentos, desde que eles compartilhem um tipo mínimo comum.

O tipo de resultado é o tipo mínimo 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

A função substring 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 crosscasting implícito para cadeia de caracteres.

-- 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 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 invocada com STRINGs devido a crosscasting implícito.

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