REGLER FÖR SQL-datatyp

Gäller för: Databricks SQL Databricks Runtime

Azure Databricks använder flera regler för att lösa konflikter mellan datatyper:

• Promotion utökar på ett säkert sätt en typ till en mer omfattande typ.
• Implicit neddragning begränsar en typ. Motsatsen till befordran.
• Implicit korskonvertering omvandlar en typ till en annan typfamilj.

Du kan också uttryckligen casta mellan många typer:

• cast-funktionen omvandlar mellan de flesta datatyper och returnerar fel om det inte går.
• try_cast funktion fungerar som cast-funktion men returnerar NULL när ogiltiga värden skickas.
• Andra inbyggda funktioner gjuts mellan typer med hjälp av tillhandahållna formatdirektiv.

Typhöjning

Typhöjning är processen för att omvandla en typ till en annan typ av samma typfamilj som innehåller alla möjliga värden av den ursprungliga typen. Därför är typhöjning en säker åtgärd. Till exempel TINYINT har ett intervall från -128 till 127. Alla möjliga värden kan höjas upp på ett säkert sätt till INTEGER.

Typpriorencelista

typprioritetens lista definierar om värden för en viss datatyp implicit kan höjas upp till en annan datatyp.

(1) För minsta vanliga typbestämningFLOAT hoppar man över för att undvika förlust av precision.

(2) För en komplex typ gäller prioritetsregeln rekursivt för dess komponentelement.

(3)OBJECT finns endast inom en VARIANT.

Strängar och NULL

Särskilda regler gäller för STRING och otypade NULL:

• NULL kan höjas upp till någon annan typ.
• STRING kan höjas upp till BIGINT, BINARY, BOOLEAN, DATE, DOUBLE, INTERVALoch TIMESTAMP. Om det faktiska strängvärdet inte kan omvandlas till den minsta vanliga typen skapar Azure Databricks ett körningsfel. När du befordrar till INTERVAL måste strängvärdet matcha intervallenheterna.

Typprecedensdiagram

Det här är en grafisk framställning av prioritetshierarkin, som kombinerar typprioritetslistan och strängar och NULL:s regler.

Minsta gemensamma typbestämning

Den minsta vanliga typen från en uppsättning typer är den smalaste typen som kan nås från typprioritetens diagram av alla element i uppsättningen av typer.

Den minsta vanliga typupplösningen används för att:

• Bestäm om en funktion som förväntar sig en parameter av en viss typ kan anropas med ett argument av en smalare typ.
• Härled argumenttypen för en funktion som förväntar sig en delad argumenttyp för flera parametrar, till exempel coalesce, in, minst eller största.
• Härled operandtyperna för operatorer som aritmetiska åtgärder eller jämförelser.
• Härled resultattypen för uttryck som case-uttryck.
• Härled element-, nyckel- eller värdetyperna för matris- och kartkonstruktorer.
• Härled resultattypen för operatorerna UNION, INTERSECT eller EXCEPT set.

Särskilda regler tillämpas om den minst vanliga typen matchar FLOAT. Om någon av de bidragande typerna är en exakt numerisk typ (TINYINT, , SMALLINTINTEGER, BIGINT, eller DECIMAL) pushas den minst vanliga typen till DOUBLE för att undvika potentiell förlust av siffror.

När den minst vanliga typen är en STRING beräknas sorteringen enligt sorteringsprioritetsregler.

Implicit nedkastning och crosscasting

Azure Databricks använder dessa former av implicit typomvandling endast vid funktions- och operatörsanrop, och endast där det kan fastställa avsikten otvetydigt.

• Implicit nedkastning

  Implicit typkonvertering omvandlar automatiskt en bredare typ till en smalare typ utan att du uttryckligen behöver ange konverteringen. Neddragning är praktiskt, men det medför risk för oväntade körningsfel om det faktiska värdet inte kan representeras i den smala typen.

  Downcasting tillämpar typprioritetslistan i omvänd ordning.

• Implicit crosscasting

  Implicit tvärtypning omvandlar ett värde från en typfamilj till en annan utan att du uttryckligen behöver ange omvandlingen.

  Azure Databricks stöder implicit korscasting från:

  • Alla enkla typer, förutom BINARY, till STRING.
  • A STRING till valfri enkel typ.

Gjutning vid funktionsanrop

Med en löst funktion eller operator gäller följande regler, i den ordning de anges, för varje parameter och argumentpar:

• Om en parametertyp som stöds är en del av argumentets typprioretdiagramhöjer Azure Databricks argumentet till den parametertypen.

  I de flesta fall anger funktionsbeskrivningen uttryckligen de typer eller kedja som stöds, till exempel "valfri numerisk typ".

  Till exempel fungerar sin(expr) på DOUBLE men accepterar alla numeriska.

• Om den förväntade parametertypen är en STRING och argumentet är en enkel typ korscastar Azure Databricks argumentet till strängparametertypen.

  Till exempel substr(str, start, len) förväntar sig att str ska vara en STRING. I stället kan du använda en numerisk eller en datum- och tidstyp.

• Om argumenttypen är en STRING och den förväntade parametertypen är en enkel typ, korsarbetar Azure Databricks strängargumentet till den bredaste parametertypen som stöds.

  Till exempel förväntar sig date_add(datum, dagar) en DATE och en INTEGER.

  Om du anropar date_add() med två STRINGs, Azure Databricks omvandlar först STRING till DATE och sedan den andra STRING till en INTEGER.

• Om funktionen förväntar sig en numerisk typ, till exempel en INTEGER, eller en DATE typ, men argumentet är en mer allmän typ, till exempel en DOUBLE eller TIMESTAMP, nedarbetar Azure Databricks implicit argumentet till den parametertypen.

  Till exempel förväntar sig en date_add(datum, dagar) en DATE och en INTEGER.

  Om du anropar date_add() med en TIMESTAMP och en BIGINT, nedkonverterar Azure Databricks TIMESTAMP genom att ta bort tidskomponenten och DATE till en BIGINTINTEGER.

• Annars genererar Azure Databricks ett fel.

Exempel

Funktionencoalesce accepterar alla typer av argument så länge de delar en minst vanlig typ.

Resultattypen är den minst vanliga typen av argument.

-- 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

Funktionensubstring förväntar sig argument av typen STRING för strängen och INTEGER för parametrarna start och längd.

-- 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) tillåter implicit omvandling till sträng.

-- 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 kan anropas med en TIMESTAMP eller BIGINT på grund av implicit nedkastning.

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

date_add kan anropas med s på grund av implicit cross-casting.

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

Relaterade

• ANSI_MODE
• kasta
• Datatyper
• Funktioner
• try_cast