SQL-adattípus szabályai

A következőkre vonatkozik: Databricks SQL Databricks Runtime

Az Azure Databricks több szabályt használ az adattípusok közötti ütközések feloldásához:

• Az előléptetés biztonságosan kibővít egy típust szélesebb típusra.
• Az implicit downcasting szűkít egy típust. Az előléptetés ellentéte.
• Az implicit keresztcímzés egy típust egy másik típuscsalád típusává alakít át.

Számos típus között is explicit módon átalakíthatunk:

• a konvertáló függvény a legtöbb típus között konvertál, és hibákat ad vissza, ha nem képes erre.
• try_cast függvény úgy működik, mint öntött függvény, de null értéket ad vissza, ha érvénytelen értékeket ad át.
• Egyéb beépített függvények típusok közötti átalakítást végeznek a megadott formátum direktívák használatával.

Típus-előléptetés

A típus-előléptetés az a folyamat, amely egy típust egy másik, azonos típusú családba helyez, amely az eredeti típus összes lehetséges értékét tartalmazza. Ezért a típus-előléptetés biztonságos művelet. Például TINYINT tartománya -128 és 127 között van. Az összes lehetséges érték biztonságosan előléptethető INTEGER-ra.

Típus előnyösségi lista

A típus elsőbbséget határozza meg, hogy egy adott adattípus értékei implicit módon előléptethetők-e egy másik adattípusra.

Adattípus	Elsőbbségi lista (a legszűkebbtől a legszélesebbig)
TINYINT	TINYINT -> SMALLINT -> INT -> BIGINT -> DECIMÁLIS -> FLOAT (1) -> DUPLA
SMALLINT	SMALLINT -> INT -> BIGINT -> DECIMÁLIS -> LEBEGŐPONTOS (1) -> DUPLA
INT	INT -> BIGINT -> DECIMÁLIS -> LEBEGŐPONTOS (1) -> DUPLA
BIGINT	BIGINT -> DECIMÁLIS -> LEBEGŐPONTOS (1) -> DUPLA
TIZEDES	DECIMÁLIS –> LEBEGŐPONTOS (1) –> DUPLA
LEBEG	FLOAT (1) -> Kettős
DUPLA	DUPLA
DÁTUM	DÁTUM –> IDŐBÉLYEGZŐ
IDŐBÉLYEG	IDŐBÉLYEG
TÖMB	TÖMB (2)
BINÁRIS	BINÁRIS
LOGIKAI ÉRTÉK	BULIÁN
INTERVALLUM	INTERVALLUM
TÉRKÉP	TÉRKÉP (2)
HÚR	HÚR
STRUKTÚRA	STRUKTÚRA (2)
VÁLTOZAT	VÁLTOZAT
TÁRGY	OBJEKTUM (3)

(1) A legkisebb gyakori típusfeloldást kihagyják a pontosság elvesztésének elkerülése érdekében.

(2) Összetett típus esetén az elsőbbségi szabály rekurzívan vonatkozik az összetevő elemeire.

(3)OBJECT csak létezik a VARIANT.

Sztringek és NULL

Speciális szabályok vonatkoznak STRING és nem típusos NULL:

• NULL bármely más típusra előléptethető.
• STRINGelőléptethető a BIGINT, BINARY, BOOLEAN, DATE, DOUBLEINTERVALés TIMESTAMP. Ha a tényleges sztringértéket nem lehet az Azure Databricks leggyakoribb típusára öntani, az futásidejű hibát eredményez. Amikor előléptet INTERVAL, a "string" értékének meg kell egyeznie az intervallumok egységeivel.

Írja be az elsőbbségi gráfot

Ez az elsőbbségi hierarchia grafikus ábrázolása, amely egyesíti a típus elsőbbségi listáját és a sztringek és NULL-ek szabályait.

Legkevésbé gyakori típusfeloldás

A típuskészlet közül a legkevésbé specifikus típus az a legszűkebb típus, amely elérhető az típus elsőbbségi gráfjából a típuskészlet összes eleme által.

A legkevésbé gyakori típusfeloldás a következő műveletekre használható:

• Döntse el, hogy egy adott típusú paramétert váró függvény meghívható-e egy szűkebb típusú argumentum használatával.
• Származtasd egy olyan függvény argumentumtípusát, amely több paraméter számára is közös argumentumtípust vár, például a koaleszkálás, a a-ban, a legkisebbvagy a legnagyobbesetén.
• Az operátorok operandustípusait( például aritmetikai műveleteket vagy összehasonlításokat) származtathatja.
• Származtassa a kifejezések, például az esetkifejezés eredménytípusát.
• A tömb és térkép konstruktorok elem-, kulcs- vagy értéktípusainak kinyerése.
• A UNION, INTERSECT vagy EXCEPT halmaz operátorainak eredménytípusát adja meg.

A speciális szabályok akkor alkalmazandók, ha a legkevésbé gyakori típus FLOAT-ra oldódik fel. Ha a típusok közül bármelyik pontos numerikus típus (TINYINT, SMALLINT, INTEGER, BIGINT vagy DECIMAL), akkor a rendszer a legkisebb közös típust tolja a DOUBLE-be, hogy elkerülje a számjegyek esetleges elvesztését.

Ha a legkevésbé gyakori típus egy STRING a rendezés kiszámítása a rendezési elsőbbségi szabályokalapján történik.

Implicit konverzió lefelé (downcasting) és keresztezett konverzió (crosscasting)

Az Azure Databricks csak a függvények és operátorok meghívására alkalmazza az implicit casting ezen formáit, és csak ott, ahol egyértelműen meghatározhatja a szándékot.

• Implicit lefelé konvertálás

  Az implicit downcasting automatikusan átalakítja a szélesebb típust egy szűkebb típusra anélkül, hogy explicit módon meg kellene adnia az átalakítást. A leszűkítés kényelmes, de váratlan futásidejű hibák kockázatát hordozza magában, ha a tényleges érték nem alakítható át szűkebb típusra.

  A downcasting a típuselőtaglistát alkalmazza fordított sorrendben.

• Implicit keresztbesorolás

  Az implicit típusváltás egy értéket konvertál az egyik típuscsaládból a másikba anélkül, hogy explicit módon kellene megadnia a konverziót.

  Az Azure Databricks támogatja az implicit keresztcímzést a következőről:

  • Bármilyen egyszerű típus, kivéve BINARY, STRING.
  • A STRING bármely egyszerű típusra.

Függvényhívások kiosztása

Megoldott függvény vagy operátor esetén az alábbi szabályok vonatkoznak a felsorolt sorrendben az egyes paraméterekre és argumentumpárokra:

• Ha egy támogatott paramétertípus az argumentum típus-elsőbbségi gráfjának része, az Azure Databricks előlépteti az argumentumot erre a paramétertípusra.

  A függvény leírása a legtöbb esetben explicit módon tartalmazza a támogatott típusokat vagy láncokat, például "bármilyen numerikus típust".

  Például a sin(expr) működik DOUBLE, de elfogad bármilyen numerikus értéket.

• Ha a várt paramétertípus egy STRING , és az argumentum egy egyszerű típus, az Azure Databricks átkonvertálja az argumentumot a sztring típusú paraméterré.

  Például a substr(str, start, len) függvény azt várja, hogy str egy STRING legyen. Ehelyett megadhat egy numerikus vagy dátum-idő típust.

• Ha az argumentumtípus egy STRING, és a várt paramétertípus egy egyszerű típus, az Azure Databricks az argumentumot a legszélesebb támogatott paramétertípusra konvertálja.

  Például a date_add(dátum, napok) egy DATE és egy INTEGER vár.

  Ha két date_add()-t ad meg, az Azure Databricks az első STRING-t , a második STRING-t pedig DATE-ként keresztkonvertálja.

• Ha a függvény numerikus típust vár, például egy INTEGER, vagy egy DATE típust, de az argumentum egy általánosabb típus, például egy DOUBLE vagy TIMESTAMP, az Azure Databricks implicit módon az argumentumot az adott paramétertípusra szórja .

  Például egy date_add(date, days) egy DATE paramétert és egy INTEGER paramétert vár.

  Ha date_add()-t és TIMESTAMP-t ad meg a BIGINT hívásával, az Azure Databricks lebontja a TIMESTAMP-ot DATE, eltávolítva az időkomponenst, és BIGINT-t egy INTEGER-re.

• Ellenkező esetben az Azure Databricks hibát jelez.

Példák

A coalesce függvény minden argumentumtípust elfogad, amíg a legkevésbé gyakori típussal rendelkeznek.

Az eredménytípus az argumentumok legkevésbé gyakori típusa.

-- 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 substring függvény a STRING típusú argumentumokat vár a szövegnek, valamint az indítási és hosszparamétereknek.

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

|| (ÖSSZEFŰZ) lehetővé teszi az implicit keresztfordítást karaktersorra.

-- 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 meghívható TIMESTAMP vagy BIGINT miatt implicit leküldéssel.

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

date_add implicit keresztvetítés miatt STRING-ekkel hívható meg.

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

Kapcsolódó

• ANSI_MODE
• öntvény
• Adattípusok
• Funkciók
• try_cast