Fonctions ① — Arithmétique, Concaténation de chaînes et Fonctions de date

Données utilisées dans cet article — la table staff

À partir de cet article, les trois suivants couvrent les fonctions intégrées à SQL. Le premier se concentre sur trois catégories : opérations arithmétiques, concaténation de chaînes et fonctions de date — toutes des expressions que tu placeras généralement dans la liste de colonnes d'un SELECT.

Le jeu de données est la table staff (10 lignes : id / name / birthday / city / salary), chargée automatiquement depuis un CSV. À travers quatre exercices pratiques, tu feras du calcul monétaire avec salary, construiras des libellés à partir de name et city, et formateras des dates depuis birthday.

Avant de te lancer dans les exercices, vérifions les définitions de colonnes et les données d'exemple de la table staff.

① Exécute PRAGMA table_info(staff); pour voir les noms de colonnes, types et clé primaire.

② Exécute SELECT * FROM staff LIMIT 5; pour prévisualiser les 5 premières lignes.

Opérateurs arithmétiques — +, -, *, /, %

Pour les calculs sur les colonnes numériques, tu disposes des 5 opérateurs arithmétiques + - * / %. SQL te permet d'écrire des expressions directement dans la liste de colonnes du SELECT, donc tu peux prendre une valeur d'une table et renvoyer son résultat calculé comme colonne séparée. Ajouter AS alias donne un nom à la colonne résultat, ce qui facilite l'affichage ou la consommation par le code en aval.

La division / se comporte différemment selon les bases : pour les divisions entre entiers, certaines bases (PostgreSQL / SQL Server) renvoient un résultat entier, tandis que d'autres (MySQL / la console de ce cours = SQLite) renvoient automatiquement un décimal.

-- 1) Calculs simples sans table
SELECT 1 + 1;       -- 2
SELECT 10 - 3;      -- 7
SELECT 3 * 4;       -- 12
SELECT 10.0 / 3;    -- 3.333...
SELECT 10 % 3;      -- 1

-- 2) Calcul utilisant une colonne (salaire annuel après une augmentation de 10%)
SELECT name, salary, salary * 1.1 AS next_year_salary
FROM staff;

-- 3) Calculer le salaire mensuel (annuel / 12)
SELECT name, salary / 12 AS monthly_salary FROM staff;

Imagine une simulation salariale : afficher « le salaire annuel de chaque employé s'il recevait une augmentation de 10% ». (Si tu l'exécutes correctement, une explication apparaîtra.)

① Depuis la table staff, extrais name, salary et salary * 1.1 avec l'alias next_year_salary — 3 colonnes au total.

② Trie par next_year_salary décroissant.

③ Vérifie que le résultat a 10 lignes et commence par Frank Tanaka 7,200,000 / 7,920,000.

Concaténation de chaînes — `||` et `CONCAT()`

Joindre plusieurs chaînes en une seule s'appelle la concaténation. Il y a deux façons de l'écrire : la console de ce cours (SQLite), PostgreSQL, Oracle et SQL Server utilisent l'opérateur `||` (deux barres verticales), tandis que MySQL utilise la fonction `CONCAT()`. SQLite supporte en fait les deux || et CONCAT(), donc cet article s'appuie sur la fonction CONCAT() plus portable.

En insérant un séparateur (': ' ou ' / ') entre les valeurs, tu peux réduire name et city en une seule colonne lisible comme « Alice Tanaka / Tokyo ». C'est un outil de prédilection pour les rapports et exports CSV où tu veux « plusieurs colonnes fusionnées en une seule ».

-- 1) L'opérateur || (SQLite / PostgreSQL / Oracle)
SELECT name || ' (' || city || ')' AS label FROM staff;

-- 2) La fonction CONCAT (MySQL / SQLite 3.40+ / PostgreSQL)
SELECT CONCAT(name, ' (', city, ')') AS label FROM staff;

-- Les deux renvoient le même résultat
-- → Alice Tanaka (Tokyo) / Bob Suzuki (Osaka) / ...

`||` vs. `CONCAT()` — lequel choisir

Pour la portabilité, `CONCAT()` est le choix le plus sûr. Elle fonctionne sur SQLite, MySQL, PostgreSQL, SQL Server (2012+) et Oracle. || est le standard SQL, mais en MySQL il signifie par défaut OU logique, donc si la production peut être MySQL, choisir CONCAT() t'évite toute réécriture.

La gestion des NULL diffère aussi : NULL || 'A' renvoie NULL avec l'opérateur ||. CONCAT(NULL, 'A') renvoie une chaîne vide en MySQL mais NULL en PostgreSQL — le comportement varie. Quand NULL peut se glisser dans tes entrées, encapsule-les avec COALESCE(colonne, '') pour convertir NULL en chaîne vide avant la concaténation (COALESCE est couvert dans le troisième article de cette série).

Imagine construire un libellé pour des fiches employés : « nom suivi d'un espace et de la ville entre parenthèses ».

① Depuis la table staff, extrais les colonnes originales name et city plus `CONCAT(name, ' (', city, ')')` avec l'alias `label`.

② Vérifie que le résultat a 10 lignes et que la colonne label contient des chaînes comme « Alice Tanaka (Tokyo) » / « Bob Suzuki (Osaka) ».

Fonctions de date — horodatage actuel et formatage

Pour des choses comme « marquer l'heure actuelle sur un nouvel enregistrement » ou « extraire juste l'année d'une date de naissance », tu utilises les fonctions de date. Les fonctions de date sont l'une des catégories où les noms et la syntaxe varient le plus entre bases — la console de ce cours (SQLite) et MySQL les appellent assez différemment.

Ce cours utilise datetime('now') / date('now') / strftime('format', valeur) de SQLite pour les exercices, avec NOW() / CURDATE() / DATE_FORMAT(valeur, 'format') de MySQL en parallèle dans la table comparative ci-dessous. Les chaînes de format ('%Y' pour l'année, '%m' pour le mois, '%d' pour le jour, etc.) sont identiques dans les deux bases, donc au moins les spécificateurs de format se transfèrent directement.

-- Comment l'écrire dans la console de ce cours (SQLite)

-- 1) Horodatage actuel / date actuelle
SELECT datetime('now') AS current_dt, date('now') AS current_d;

-- 2) Spécificateur de format (année seule / année-mois)
SELECT strftime('%Y', '1990-04-15') AS year_only;       -- '1990'
SELECT strftime('%Y-%m', '1990-04-15') AS year_month;   -- '1990-04'

-- 3) Format appliqué à une colonne
SELECT name, strftime('%Y', birthday) AS birth_year FROM staff;

-- Référence : la même chose en MySQL
--   SELECT NOW(), CURDATE();
--   SELECT DATE_FORMAT(birthday, '%Y') FROM staff;

Extrayons l'horodatage actuel et la date actuelle depuis la console de ce cours. L'exécuter suffit — pas de vérification exacte.

① Récupère datetime('now') avec l'alias current_dt et date('now') avec l'alias current_d.

② Vérifie que le résultat est 1 ligne × 2 colonnes, avec current_dt affichant l'horodatage actuel au format « YYYY-MM-DD HH:MM:SS » et current_d affichant la date actuelle au format « YYYY-MM-DD ».

Imagine une liste d'employés qui a besoin d'une colonne « année de naissance » séparée.

① Depuis la table staff, extrais name, birthday et `strftime('%Y', birthday)` avec l'alias `birth_year` — 3 colonnes au total.

② Vérifie que le résultat a 10 lignes. Pour Alice Tanaka, tu devrais voir birthday=1990-04-15 et birth_year='1990' — seule l'année se retrouve dans la nouvelle colonne.

Imagine une requête : « montre les jeunes employés (nés dans les années 1990) par ordre de naissance ».

① Depuis la table staff, extrais name, birthday et strftime('%Y', birthday) AS birth_year.

② Filtre sur les lignes où birth_year est entre '1990' et '1999' inclus (utilise BETWEEN).

③ Trie par birthday croissant (le plus ancien en premier) et garde seulement les 3 premières lignes.

④ Vérifie que le résultat est 3 lignes : Alice 1990-04-15 / Grace 1991-05-25 / Carol 1992-11-03.