Regras de tipo de dados SQL

Aplica-se a: Databricks SQL Databricks Runtime

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

• A promoção expande com segurança um tipo para um tipo mais amplo.
• O downcasting implícito estreita um tipo. O oposto da promoção.
• O crosscasting implícito transforma um tipo em um tipo de outra família de tipos.

Você também pode transmitir explicitamente entre vários tipos:

• A função Cast transmite entre a maioria dos tipos e retorna erros se não for possível.
• try_cast função funciona como função de transmissão mas retorna NULL quando passado valuesinválido.
• Outras funções incorporadas são transmitidas entre tipos usando diretivas de formato fornecidas.

Tipo de promoção

A promoção de tipo é o processo de converter um tipo noutro tipo da mesma família de tipos, que contém todos os possíveis values 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 possíveis valores de values podem ser promovidos com segurança para INTEGER.

Precedência de tipo list

A precedência de tipo list define se values de um determinado tipo de dados pode ser promovido a outro tipo de dados de forma implícita.

(1) Para o tipo menos comum, a resoluçãoFLOAT é ignorada 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 para 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 precedência do tipo list e as cadeias de caracteres e as regras de NULLs.

Resolução de tipo menos comum

O tipo menos comum de uma set de tipos é o tipo mais estreito alcançável a partir do gráfico de precedência de tipo por todos os elementos da set 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 vários parameters, como coalescer, em, mínimoou máximo.
• Derive os tipos de operando para operadores, como operações aritméticas ou comparações.
• Derive o tipo de resultado para expressões como a expressão de maiúsculas e minúsculas.
• Derive os tipos de elemento, chave ou valor para construtores de matriz e mapa .
• Derive o tipo de resultado dos operadores UNION, INTERSECT ou EXCEPT de set.

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 (, , , , ou TINYINT), o tipo menos comum é empurrado para SMALLINT evitar a perda potencial de dígitos. INTEGERBIGINTDECIMALDOUBLE

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 where ele pode 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 precedência do tipo list na ordem inversa.

• Crosscasting implícito

  O crosscasting implícito converte um valor de uma família de tipos para outra sem exigir que você especifique a transmissão explicitamente.

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

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

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 aceitará qualquer numérico.

• Se o tipo de parâmetro esperado for um STRING e o argumento for um tipo simples, o Azure Databricks fará a conversão do argumento para o tipo de parâmetro string.

  Por exemplo, substr(str, start, len) espera str ser um STRING. Em vez disso, você pode passar um tipo numérico ou datetime.

• Se o tipo de argumento for um STRING e o tipo de parâmetro esperado for um tipo simples, o Azure Databricks fará a conversão do argumento string para o tipo de parâmetro com suporte mais amplo.

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

  Se você invocar date_add() com dois STRINGs, o Azure Databricks fará a conversão cruzada do primeiro STRING para DATE e o segundo STRING para um INTEGERarquivo .

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

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

  Se você invocar date_add() com a TIMESTAMP e a BIGINT, o Azure Databricks reduzirá o TIMESTAMP para DATE removendo o componente de tempo e o BIGINT para um INTEGER.

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

Exemplos

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

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

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

-- 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 o crosscasting implícito 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

Relacionada

• ANSI_MODE
• Elenco
• Tipos de dados
• Funções
• try_cast