SQL-adattípus szabályai

A következőkre vonatkozik: jelölje be az igennel jelölt jelölőnégyzetet 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 cast függvény a legtöbb típus között átalakít, és hibát ad vissza, ha nem sikerül.
try_cast függvény a leadott függvényhez hasonlóan működik, 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 -> DECIMAL -> FLOAT (1) -> DOUBLE
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
DECIMAL	DECIMÁLIS –>LEBEGŐPONTOS (1) –> DUPLA
FLOAT	FLOAT (1) -> DOUBLE
DOUBLE	DOUBLE
DATE	DÁTUM –> IDŐBÉLYEGZŐ
TIMESTAMP	TIMESTAMP
ARRAY	TÖMB (2)
BINARY	BINARY
BOOLEAN	BOOLEAN
INTERVAL	INTERVAL
FÖLDRAJZ	FÖLDRAJZ (BÁRMELY)
GEOMETRIA	GEOMETRIA (BÁRMELY)
MAP	TÉRKÉP (2)
STRING	STRING
STRUCT	STRUKTÚRA (2)
VARIANT	VARIANT
OBJECT	OBJEKTUM (3)

(1) A legkisebb gyakori típusfeloldásFLOAT kihagyása 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 egy VARIANT-ban létezik.

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.

Az elsőbbségi szabályok grafikus ábrázolása

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ármaztassa le egy olyan függvény argumentumtípusát, amely több paraméterhez közös argumentumtípust vár, például coalesce, in, least vagy greatest.
Az operátorok operandustípusait( például aritmetikai műveleteket vagy összehasonlításokat) származtathatja.
Származtassa a kifejezések eredménytípusát, például az eset kifejezést.
A tömb- és térképkonstruktorok 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 downcasting

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. Az GEOGRAPHY és GEOMETRY adattípusok soha nincsenek leszűkítve.

Implicit keresztkiosztá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 a BINARY, a GEOGRAPHY, és a GEOMETRY a STRING.
- Bármilyen egyszerű típusra vonatkozó STRING, kivéve GEOGRAPHY és GEOMETRY.

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

A sin(expr) például DOUBLE-en működik, de bármilyen numerikus értéket elfogad.
Ha a várt paramétertípus egy STRING, és az argumentum egy egyszerű típus, az Azure Databricks átalakítja az argumentumot 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 a sztring argumentumot a legszélesebb támogatott paramétertípusra keresztbe szórja .

Például a date_add(dátum, nap) függvény egy DATE és egy INTEGER paramétert vár.

Ha date_add()-t két STRING-vel hív meg, az Azure Databricks az első STRING-et DATE-re és a második STRING-ot INTEGER-ré kereszttípusúvá alakítja.
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 .

A date_add(dátum, nap) például egy DATE és egy INTEGER elvár.

Ha egy date_add() és egy TIMESTAMP paraméterrel hívja meg a BIGINT, akkor az Azure Databricks konvertálja a TIMESTAMP elemet DATE típusra az időkomponens eltávolításával, és a BIGINT elemet egy INTEGER típusra.
Ellenkező esetben az Azure Databricks hibát jelez.

Examples

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

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

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 átalakítást karakterláncra.

-- 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 implicit típuskényszerítés miatt.

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

date_add implicit keresztcímzés miatt s-vel STRINGhívhatók meg.

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

Visszajelzés

Hasznosnak találta ezt az oldalt?

Last updated on 2025-12-05