règles de type de données SQL

Databricks Runtime utilise plusieurs règles pour résoudre les conflits entre les types de données. Au cœur de cette résolution de conflit se trouve la liste des priorités des types qui définit si les valeurs d’un type de données donné peuvent être promues de manière implicite vers un autre type de données.

En outre, lorsque Databricks Runtime appelle une fonction, il emploie également des passer et crosscasting implicites pour faire correspondre les arguments de fonction aux paramètres de fonction dans la mesure du possible.

Priorité des types

Databricks Runtime utilise plusieurs règles qui régissent le mode de résolution des conflits entre les types de données. Au cœur de cette résolution de conflit se trouve la liste des priorités des types qui définit si les valeurs d’un type de données donné peuvent être promues de manière implicite vers un autre type de données.

Type de données Liste des priorités (du plus étroit au plus large)
TINYINT TINYINT- > smallint- > int- > bigint- > Decimal- > float-- > double
SMALLINT SMALLINT- > int- > bigint- > Decimal- > float > - > double
INT INT- > bigint- > Decimal- > float > - > double
bigint BIGINT- > Decimal- > float > - > double
DECIMAL Decimal- > float > - > double
FLOAT FLOAT (1) - double
DOUBLE DOUBLE
DATE DATE- > horodateur
timestamp timestamp
ARRAY TABLEAU (2)
BINARY BINARY
BOOLEAN BOOLEAN
INTERVAL INTERVAL
MAP Carte (2)
STRING STRING
STRUCT STRUCT (2)

(1) la valeur la plus faible de la résolution de type commun est ignorée pour éviter la perte de précision.

(2) pour un type complexe, la règle de précédence s’applique de manière récursive à ses éléments de composant.

Littéraux de chaîne et NULL

Des règles spéciales s’appliquent aux littéraux de chaîne et aux valeurs NULL non typées.

Une valeur NULL peut être promue à n’importe quel autre type. Un littéral de chaîne peut être promu en un type de données simple.

Il s’agit d’une représentation graphique de la hiérarchie de précédence :

Graphical representation of precedence rules

Résolution de type la moins courante

Le type le moins courant d’un ensemble de types est le type le plus étroit accessible à partir de la liste de précédence par tous les éléments de l’ensemble de types.

La résolution de type la moins courante est utilisée pour :

  • Déterminez si une fonction qui attend un paramètre d’un type donné peut être appelée à l’aide d’un argument d’un type plus étroit.
  • Dérivez le type d’argument pour une fonction qui attend un type d’argument partagé pour plusieurs paramètres, tels que COALESCE, in, leastou maximum.
  • Dérivez les types d’opérandes pour les opérateurs tels que les opérations arithmétiques ou les comparaisons.
  • Dérivez le type de résultat pour les expressions telles que l' expression case.
  • Dérivez les types d’élément, de clé ou de valeur pour les constructeurs de tableau et de mappage .
  • Dérivez le type de résultat des opérateurs Union, Intersect ou except .

Des règles spéciales sont appliquées si le type le moins courant correspond à FLOAT :

Si l’un des types contributeurs est INTEGER , BIGINT , ou DECIMAL le type le moins courant est envoyé à DOUBLE pour éviter une perte potentielle de chiffres.

Passer et crosscasting implicites

Databricks Runtime utilise ces formes de conversion implicite uniquement sur l’appel de fonction et d’opérateur, et uniquement où il peut déterminer clairement l’intention.

  • Passer implicite

    Les passer implicites effectuent automatiquement un cast d’un type plus large vers un type plus étroit sans que vous ayez besoin de spécifier explicitement le cast. Passer est pratique, mais elle présente le risque d’erreurs d’exécution inattendues si la valeur réelle n’est pas représentable dans le type étroit.

  • Crosscasting implicite

    Crosscasting implicite convertit une valeur d’une famille de types à une autre sans que vous ayez besoin de spécifier explicitement le cast. Databricks Runtime prend en charge la conversion implicite de tout type simple en STRING , mais pas l’inverse. Toutefois, un STRING littéral peut être converti en un autre type simple, car Databricks Runtime peut dériver la sécurité du cast lors de la compilation de la requête. Alors que les valeurs de tous les types simples peuvent être représentées en tant que STRING s, ce n’est évidemment pas le cas lors de la conversion STRING d’une valeur en tout autre type simple.

Cast sur l’appel de fonction

À partir d’une fonction ou d’un opérateur résolu (e), les règles suivantes s’appliquent, dans l’ordre dans lequel elles sont répertoriées, pour chaque paire de paramètres et d’arguments :

  • Si un type de paramètre pris en charge fait partie de la chaîne de précédence des types de l’argument, Databricks Runtime promeut l’argument pour ce type de paramètre.

    Dans la plupart des cas, la description de fonction indique explicitement la chaîne ou les types pris en charge, tels que « tout type numérique ».

    Par exemple, Sin (expr) fonctionne sur, mais accepte n’importe quelle valeur numérique.

  • Si le type de paramètre attendu est un STRING et que l’argument est un type simple Databricks Runtime crosscasts l’argument du type de paramètre de chaîne.

    Par exemple, substr (STR, Start, Len) s’attend à être un STRING . Au lieu de cela, vous pouvez passer un type numérique ou DateTime.

  • Si la fonction attend un type numérique, tel qu’un INTEGER , ou un DATE type, mais que l’argument est un type plus général, tel qu’un DOUBLE ou un TIMESTAMP , Databricks Runtime implicitement downcasts l’argument de ce type de paramètre.

    Par exemple, un DATE_ADD (date, Days) attend un et un INTEGER .

    Si vous appelez date_add() avec un TIMESTAMP et un BIGINT , Databricks Runtime downcasts le TIMESTAMP à DATE en supprimant le composant d’heure et le BIGINT à un INTEGER .

  • Dans le cas contraire, Databricks Runtime génère une erreur.

Exemples

La fonction COALESCE accepte tout ensemble de types d’arguments tant qu’ils partagent un type le moins courant.

Le type de résultat est le type le moins courant des arguments.

-- 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
> SELECT typeof(coalesce(1, DATE'2020-01-01'));
Error: Incompatible types [INT, DATE]

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

La fonction SUBSTRING attend des arguments de type pour la chaîne et INTEGER pour les paramètres start et 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

-- No crosscasting from STRING to INTEGER
> SELECT substring('hello', str, 2)
  FROM VALUES(CAST('1' AS STRING)) AS T(str);
Error: Argument 2 requires an INT type.

-- Crosscasting from INTEGER to STRING
> SELECT substring(12345, 2, 2);
 23

|| (CONCAt) autorise la crosscasting implicite à String.

-- 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 peut être appelée avec ou BIGINT en raison de passer implicites.

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