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:

• Befordran expanderar på ett säkert sätt en typ till en bredare typ.
• Implicit neddragning begränsar en typ. Motsatsen till befordran.
• Implicit korscasting omvandlar en typ till en typ av en annan typfamilj.

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

• cast-funktionen gjuts mellan de flesta typer och returnerar fel om den inte kan.
• try_cast-funktion fungerar som cast-funktion men returnerar NULL när den får ogiltiga värden values.
• 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 values 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 dess möjliga values kan säkert befordras till INTEGER.

Typprioritet list

typprioriteten list definierar om values av en viss datatyp implicit kan höjas upp till en annan datatyp.

(1) För minsta vanliga typmatchningFLOAT hoppas 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 strängvärdet måste det matcha intervallenheterna.

Typpriorencediagram

Det här är en grafisk beskrivning av prioritetshierarkin, som kombinerar typprioritet list och strängar och regler för NULLs.

Minsta vanliga typmatchning

Den minst vanliga typen från en set av typer är den smalaste typen som kan nås från typprioretdiagram av alla element i set 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 parameters, till exempel sammanfogar, i, minstaeller största.
• Härled operandtyperna för operatorer som aritmetiska åtgärder eller jämförelser.
• Härled resultattypen för uttryck som skiftlägesuttrycket.
• Härled element-, nyckel- eller värdetyperna för matris- och kartkonstruktorer.
• Härled resultattypen för operatorerna UNION, INTERSECT eller EXCEPTset.

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 gjutning endast på funktions- och operatoranrop, och endast where det kan entydigt fastställa avsikten.

• Implicit nedkastning

  Implicit nedkastning omvandlar automatiskt en bredare typ till en smalare typ utan att du uttryckligen behöver ange casten. 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 typprioriteten list i omvänd ordning.

• Implicit crosscasting

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

  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 typprioretdiagram hö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 förväntar sig substr(str, start, len)str I stället kan du skicka en numerisk typ eller datetime-typ.

• 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, korscastar Azure Databricks den första STRING till DATE och 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, nedarbetartill genom att TIMESTAMP ta bort tidskomponenten och DATE till en BIGINT.

• Annars genererar Azure Databricks ett fel.

Exempel

Funktionen sammanslagning accepterar alla set argumenttyper 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

Funktionen delsträng förväntar sig argument av typen STRING för strängen och INTEGER för start- och längd-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) tillåter implicit korscasting 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 STRINGs på grund av implicit korscasting.

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

Relaterade

• ANSI_MODE
• kasta
• Datatyper
• Funktioner
• try_cast