Condividi tramite

Regole del tipo di dati SQL

Si applica a:segno di spunta sì Databricks SQL segno di spunta sì Databricks Runtime

Azure Databricks usa diverse regole per risolvere i conflitti tra i tipi di dati:

  • La promozione espande in modo sicuro un tipo a un tipo più ampio.
  • Il downcast implicito restringe un tipo. L'opposto della promozione.
  • Il crosscast implicito trasforma un tipo in un tipo di un'altra famiglia di tipi.

È anche possibile eseguire il cast esplicito tra molti tipi:

Promozione del tipo

La promozione del tipo è il processo di cast di un tipo in un altro tipo della stessa famiglia di tipi che contiene tutti i valori possibili del tipo originale. Pertanto, la promozione del tipo è un'operazione sicura. Ad esempio TINYINT , ha un intervallo compreso tra -128 e 127. Tutti i valori possibili possono essere promossi in modo sicuro a INTEGER.

Elenco di precedenza dei tipi

L'elenco di precedenza dei tipi definisce se i valori di un determinato tipo di dati possono essere promossi in modo implicito a un altro tipo di dati.

Tipo di dati Elenco di precedenza (da più stretto a più largo)
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
BOOLEAN BOOLEAN
INTERVAL INTERVAL
GEOGRAFIA GEOGRAFIA(ANY)
GEOMETRIA GEOMETRIA(ANY)
MAP MAP (2)
STRING STRING
STRUCT STRUCT (2)
VARIANT VARIANT
OBJECT OGGETTO (3)

(1) Per la risoluzioneFLOAT dei tipi meno comune viene ignorata per evitare la perdita di precisione.

(2) Per un tipo complesso, la regola di precedenza si applica in modo ricorsivo ai relativi elementi componenti.

(3)OBJECT esiste solo all'interno di un oggetto VARIANT.

Stringhe e NULL

Le regole speciali si applicano a STRING e non tipizzato NULL:

  • NULL può essere alzato di livello a qualsiasi altro tipo.
  • STRINGpuò essere alzato di livello a BIGINT, BINARYBOOLEAN, DATE, DOUBLE, INTERVAL, e TIMESTAMP. Se non è possibile eseguire il cast del valore stringa effettivo al tipo meno comune di Azure Databricks, viene generato un errore di runtime. Quando si alza di INTERVAL livello il valore stringa deve corrispondere alle unità di intervallo.

Grafico della precedenza dei tipi

Si tratta di una rappresentazione grafica della gerarchia di precedenza, combinando l'elenco di precedenza dei tipi e le stringhe e le regole NULL.

Rappresentazione grafica delle regole di precedenza

Risoluzione dei tipi meno comune

Il tipo meno comune di un set di tipi è il tipo più stretto raggiungibile dal grafico di precedenza del tipo da tutti gli elementi del set di tipi.

La risoluzione dei tipi meno comune viene usata per:

  • Decidere se una funzione che prevede un parametro di un determinato tipo può essere richiamata usando un argomento di un tipo più stretto.
  • Derivare il tipo di argomento per una funzione che prevede un tipo di argomento condiviso per più parametri, ad esempio coalesce, in, least o greatest.
  • Derivare i tipi di operando per operatori quali operazioni aritmetiche o confronti.
  • Derivare il tipo di risultato per espressioni come l'espressione case.
  • Derivare i tipi di elemento, chiave o valore per i costruttori array e mappa.
  • Derivare il tipo di risultato degli operatori di set UNION, INTERSECT o EXCEPT .

Le regole speciali vengono applicate se il tipo meno comune viene risolto in FLOAT. Se uno dei tipi che contribuiscono è un tipo numerico esatto (TINYINT, SMALLINT, INTEGERBIGINT, o DECIMAL), viene eseguito il push del tipo meno comune per DOUBLE evitare la potenziale perdita di cifre.

Quando il tipo meno comune è un STRING, la collation viene calcolata seguendo le regole di precedenza della collation .

Downcast implicito e crosscasting

Azure Databricks usa queste forme di cast implicito solo sulla chiamata di funzione e operatore e solo dove può determinare in modo non ambiguo la finalità.

  • Conversione discendente implicita

    Il downcast implicito esegue automaticamente il cast di un tipo più ampio a un tipo più stretto senza che sia necessario specificare il cast in modo esplicito. Il downcast è pratico, ma comporta il rischio di errori di runtime imprevisti se il valore effettivo non può essere rappresentato nel tipo narrow.

    Il downcast applica l'elenco di precedenza del tipo in ordine inverso. I tipi di dati GEOGRAPHY e GEOMETRY non sono mai downcast.

  • Trasmissione incrociata implicita

    Il crosscast implicito esegue il cast di un valore da una famiglia di tipi a un'altra senza che sia necessario specificare il cast in modo esplicito.

    Azure Databricks supporta il crosscast implicito da:

    • Qualsiasi tipo semplice, ad eccezione di BINARY, GEOGRAPHY e GEOMETRY, verso STRING.
    • Oggetto STRING a qualsiasi tipo semplice, tranne GEOGRAPHY e GEOMETRY.

Cast alla chiamata di funzione

Data una funzione o un operatore risolto, si applicano le regole seguenti, nell'ordine in cui sono elencate, per ogni parametro e coppia di argomenti:

  • Se un tipo di parametro supportato fa parte del grafico di precedenza del tipo dell'argomento, Azure Databricks promuove l'argomento a tale tipo di parametro.

    Nella maggior parte dei casi la descrizione della funzione indica in modo esplicito i tipi o la catena supportati, ad esempio "qualsiasi tipo numerico".

    Ad esempio, sin(expr) opera su DOUBLE ma accetterà qualsiasi valore numerico.

  • Se il tipo di parametro previsto è STRING e l'argomento è un tipo semplice, Azure Databricks esegue il crosscast dell'argomento al tipo di parametro stringa.

    Ad esempio, substr(str, start, len) prevede str che sia .STRING È invece possibile passare un tipo numerico o datetime.

  • Se il tipo di argomento è un STRING e il tipo di parametro previsto è un tipo semplice, Azure Databricks esegue la conversione dell'argomento stringa al tipo di parametro supportato più ampio.

    Ad esempio, date_add(data, giorni) si aspetta un DATE e un INTEGER.

    Se si richiama date_add() con due STRINGs, Azure Databricks esegue il crosscast del primo STRING a DATE e il secondo STRING in un oggetto INTEGER.

  • Se la funzione prevede un tipo numerico, ad esempio un tipo INTEGER o DATE, ma l'argomento è di un tipo più generale, come DOUBLE o TIMESTAMP, Azure Databricks esegue implicitamente il downcast dell'argomento a quel tipo di parametro.

    Ad esempio, un date_add(data, giorni) si aspetta un DATE e un INTEGER.

    Se si richiama date_add() con un TIMESTAMP e un BIGINT, Azure Databricks esegue il downcast di TIMESTAMP a DATE rimuovendo la componente temporale e BIGINT a un INTEGER.

  • In caso contrario, Azure Databricks genera un errore.

Examples

La coalesce funzione accetta qualsiasi set di tipi di argomento purché condividono un tipo meno comune.

Il tipo di risultato è il tipo meno comune degli argomenti.

-- 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 funzione prevede argomenti di tipo STRING per la stringa e INTEGER per i parametri start e 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) consente il crosscast implicito nella stringa.

-- 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 può essere richiamato con un oggetto TIMESTAMP o con un oggetto BIGINT a causa del casting implicito verso il basso.

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

date_add può essere richiamato con STRINGs a causa del crosscast implicito.

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