Chaînes, nombres, booléens et conversion de type implicite

Les données qu'on utilise — la table typed_demo

Quand tu crées une colonne, tu déclares un type comme INTEGER / TEXT / REAL, et ça décide de la façon dont la colonne traite les valeurs qu'elle contient.

Dans cet article tu vas parcourir la façon dont les chaînes, les nombres et les booléens sont stockés et comparés en SQL, et en quoi la gestion des types par la console de ce cours (aussi appelée type affinity / affinité de type dans la documentation SQLite) diffère des types stricts de MySQL.

Avant de passer aux exercices, jette un œil rapide aux définitions de colonnes et aux lignes d'exemple de la table typed_demo. (Exécute correctement et l'explication apparaîtra.)

① Utilise PRAGMA table_info(typed_demo); pour vérifier les noms de colonnes, les types déclarés et la clé primaire.

② Utilise SELECT * FROM typed_demo; pour prévisualiser toutes les lignes.

Type déclaré vs classe de stockage — chaque valeur porte son propre type

Le type qu'une valeur a réellement à l'exécution s'appelle sa classe de stockage, et il en existe cinq : NULL / INTEGER (entiers) / REAL (décimaux) / TEXT (chaînes) / BLOB (binaire).

Tu peux vérifier la classe de stockage actuelle d'une valeur avec la fonction typeof(valeur).

Si tu mets une chaîne qui ressemble à un nombre dans une colonne déclarée TEXT, la politique de la colonne est « traiter ça comme du texte », donc ça reste une chaîne.

Mais si tu mets une chaîne qui ressemble à un nombre comme '123' dans une colonne déclarée INTEGER, la politique de la colonne se déclenche et convertit ça en entier 123 avant de le stocker.

-- Exemple autonome rapide montrant « le type déclaré de la colonne décide du type stocké »
-- Une chaîne qui ressemble à un nombre dans une colonne INTEGER est convertie en entier
CREATE TABLE IF NOT EXISTS aff_probe(num INTEGER, txt TEXT);
INSERT OR IGNORE INTO aff_probe VALUES ('123','123'), ('hello','hello');

-- Utilise typeof pour inspecter la classe de stockage réelle
SELECT num, typeof(num) AS num_class,
       txt, typeof(txt) AS txt_class
FROM aff_probe;
-- colonne num : '123' devient un entier, 'hello' ne peut pas être converti donc reste en texte
-- colonne txt : les deux restent en texte

Imagine que tu veuilles vérifier « quel type (integer / real / string) chaque valeur de typed_demo est réellement stocké ».

① Récupère les colonnes a, b, c et flag de typed_demo.

② Ajoute aussi un typeof() pour chaque colonne, avec les alias a_class / b_class / c_class / flag_class.

③ Ne filtre pas les lignes — les deux lignes doivent apparaître dans le résultat.

Les chaînes et les nombres basculent dans un sens et dans l'autre — '123' et 123

Quand un nombre est attendu, une chaîne est convertie automatiquement en nombre ; quand une chaîne est attendue, un nombre est converti en chaîne.

Par exemple, '123' + 0 convertit la chaîne '123' en nombre 123 et renvoie 123, donc les chaînes qui ressemblent à des nombres peuvent être lâchées directement dans des opérations arithmétiques.

Dans l'autre sens, 123 || '' (|| est la concaténation de chaînes) transforme le nombre en chaîne.

Les opérateurs de comparaison fonctionnent de la même façon : si un côté est une colonne INTEGER, l'autre côté est aligné en nombre ; si un côté est une colonne TEXT, l'autre côté est aligné en chaîne.

Mais avec deux littéraux bruts comme '1' = 1, il n'y a pas de colonne pour fixer la politique, donc les valeurs restent de types différents et le résultat est 0 (pas de correspondance).

-- Observe la conversion chaîne <-> nombre (exemple en lecture seule)
SELECT '123' + 0     AS str_to_num,   -- la chaîne devient nombre 123
       'abc' + 0     AS not_a_num,    -- conversion impossible, devient 0
       123 || ''     AS num_to_str,   -- le nombre devient chaîne '123'
       typeof('123' + 0) AS class_after_add,
       '1' = 1       AS literal_cmp,  -- littéraux bruts : 0 (pas de correspondance)
       7 / 2         AS int_div,      -- entier / entier = entier 3
       7.0 / 2       AS real_div;     -- un décimal dans le mélange donne 3.5

Imagine que tu veuilles « traiter les chaînes qui ressemblent à des nombres dans la colonne b (TEXT) de typed_demo comme des nombres pour les opérations arithmétiques et les comparaisons ».

① Récupère la colonne b de typed_demo.

② Ajoute b + 0 avec l'alias b_plus0. Les lignes qui ressemblent à des nombres deviennent des nombres, et les lignes non numériques deviennent 0.

③ Ajoute ensuite un test pour savoir si b en tant que nombre est supérieur à 5, avec l'alias gt5 (puisque tu compares une valeur de la colonne b à un littéral numérique, la comparaison se fait entre nombres).

Booléens — TRUE / FALSE sont stockés en 1 / 0

SQL n'a pas de type booléen autonome — les valeurs de vérité sont représentées par les entiers 1 (vrai) et 0 (faux).

Les expressions de comparaison comme 1 = 1 ou 3 > 2 renvoient 1 pour vrai et 0 pour faux.

Partout où tu peux écrire une condition, comme CASE WHEN colonne THEN ..., tout ce qui n'est pas 0 (typiquement 1) est traité comme vrai, et 0 est traité comme faux.

NULL est un troisième état qui n'est ni vrai ni faux (« inconnu »), et dans les conditions WHERE ou CASE il se comporte comme faux au sens où la ligne est « non retenue ».

-- Les expressions de comparaison renvoient 1 / 0 (exemple en lecture seule)
SELECT (1 = 1)  AS is_true,    -- 1
       (1 = 2)  AS is_false,   -- 0
       (3 > 2)  AS gt,         -- 1
       TRUE     AS true_kw,    -- équivalent à 1
       FALSE    AS false_kw;   -- équivalent à 0

-- Utilise une colonne flag directement comme condition
SELECT a, flag,
  CASE WHEN flag THEN 'enabled' ELSE 'disabled' END AS state
FROM typed_demo;

Imagine que tu veuilles « transformer la colonne flag (entier 1 / 0) de typed_demo en une étiquette lisible ».

① Récupère a et flag de typed_demo.

② Utilise flag directement comme condition dans un CASE WHEN ... et ajoute une troisième colonne avec l'alias state qui renvoie 'enabled' pour les lignes vraies (1) et 'disabled' pour les lignes fausses (0).

③ Pour aussi voir ce qu'une expression de comparaison renvoie pour vrai / faux, ajoute une quatrième colonne avec le résultat de flag = 1 aliasée is_on.

Comparé aux types stricts de MySQL

Ce que tu as vu jusqu'ici, c'est la conversion de type implicite — les valeurs sont remodelées avec souplesse selon le contexte.

À l'inverse, MySQL et Oracle ont des types stricts : quand tu déclares CHAR(10) / VARCHAR(255) / TEXT pour les chaînes ou INT / DECIMAL(10,2) pour les nombres, seules les valeurs de ce type passent, et la longueur et la précision sont appliquées exactement telles que déclarées.

Un nombre ne se glissera généralement pas dans une colonne chaîne via une conversion implicite, et les valeurs qui dépassent la longueur déclarée vont soit lever une erreur, soit être tronquées.

Le code ci-dessous est la façon MySQL de déclarer les types.

La console de ce cours n'applique pas les vérifications de longueur par conception, donc quand tu étudies les contraintes de longueur comme VARCHAR(10), retiens juste « c'est comme ça que MySQL l'écrit » — cette syntaxe s'applique aussi quand tu passes à d'autres bases.

-- Déclarations de types stricts en MySQL (lecture seule — ne pas exécuter dans cette console)
CREATE TABLE product (
  id        INT            PRIMARY KEY,   -- entiers seulement
  code      CHAR(8),                      -- longueur fixe, 8 caractères
  name      VARCHAR(100)   NOT NULL,      -- jusqu'à 100 caractères
  note      TEXT,                         -- longue chaîne
  price     DECIMAL(10,2)  NOT NULL,      -- 8 chiffres + 2 décimales
  in_stock  TINYINT(1)     DEFAULT 0      -- flag 0/1 pour les booléens
);

-- En MySQL, mettre 101 caractères dans un VARCHAR(100) va
-- soit lever une erreur, soit tronquer selon les paramètres.
-- Mettre 'abc' dans une colonne INT va lever une erreur.
-- La console de ce cours exécute tout ça grâce à la conversion de type implicite.

Astuces — CHAR vs VARCHAR et quand utiliser chacun

`CHAR(n)` est à longueur fixe : si la valeur est plus courte que n caractères, elle est complétée par des espaces de fin pour remplir les n caractères.

`VARCHAR(n)` est à longueur variable : il garde la valeur à sa longueur réelle (n est la borne supérieure).

Choisis `CHAR` quand : la valeur est toujours de longueur fixe, comme un code pays ('JP' / 'US'), un code de genre, ou une section de longueur fixe d'un hash. La disposition fixe peut être marginalement plus rapide pour les comparaisons et le calcul de position d'enregistrement.

Choisis `VARCHAR` quand : les longueurs varient — noms, adresses e-mail, titres, descriptions, etc. Il ne prend que la place dont il a réellement besoin, donc le stockage reste plus petit.

En cas de doute, `VARCHAR` est le défaut le plus sûr. Utiliser CHAR pour des données à longueur variable peut provoquer des décalages de comparaison subtils à cause du padding par espaces de fin (par ex. 'JP' vs 'JP ' traités de façon incohérente).

Imagine que tu veuilles « faire la somme et la moyenne des valeurs de la colonne b (TEXT) de typed_demo comme des nombres, et compter combien de lignes sont vraies dans la colonne flag ». Ça montre que la conversion de type implicite te permet d'agréger numériquement des colonnes texte.

① Récupère la somme de la colonne b de typed_demo aliasée sum_b, et la moyenne aliasée avg_b. Seules les lignes qui ressemblent à des nombres sont additionnées comme nombres.

② Dans la même requête, récupère la somme de la colonne flag aliasée enabled_count (puisque flag vaut 1 / 0, la somme est égale au nombre de lignes vraies).

③ Ne groupe par rien — renvoie une seule ligne de synthèse pour toute la table.