1. L'Opérateur de Non-Égalité : <> ou !=

Dans MySQL, l'opérateur de non-égalité est représenté par les symboles <> ou !=. Ces deux syntaxes sont équivalentes et servent à filtrer les enregistrements où la valeur d'une colonne n'est pas égale à une valeur spécifiée. C'est un outil fondamental pour exclure des données spécifiques d'un ensemble de résultats.

Par exemple, pour récupérer la liste des employés dont le statut n'est pas "terminé" :

SELECT id_employe, nom_complet, statut_contrat
FROM employes
WHERE statut_contrat <> 'terminé';

2. La Gestion des Valeurs NULL

Les valeurs NULL représentent l'absence de données. Leur manipulation en SQL diffère des autres types de données en raison de la logique à trois valeurs (TRUE, FALSE, UNKNOWN).

2.1. Vérification de NULL avec IS NULL et IS NOT NULL

Il est crucial de comrpendre qu'une comparaison directe avec NULL en utilisant l'opérateur d'égalité (=) ou de non-égalité (<>) ne renverra jamais TRUE ni FALSE, mais toujours UNKNOWN. Pour vérifier si une colonne contient ou ne contient pas de valeur NULL, il faut utiliser les opérateurs dédiés :

• IS NULL : Retourne TRUE si l'expression est NULL.
• IS NOT NULL : Retourne TRUE si l'expression n'est pas NULL.

Exemple : Pour trouver toutes les commandes sans date de livraison définie :

SELECT id_commande, montant
FROM commandes
WHERE date_livraison IS NULL;

2.2. L'Opérateur de Comparaison Sûr : <=>

L'opérateur <=> (opérateur d'égalité sûr) offre une manière de comparer des valeurs, y compris NULL, de manière prévisible. Il renvoie TRUE (1) si les deux opérandes sont égaux, même si les deux sont NULL. Il renvoie FALSE (0) si les opérandes sont différents, ou si l'un est NULL et l'autre non.

• A <=> B est TRUE si A et B sont identiques.
• A <=> NULL est TRUE si A est NULL.
• A <=> NULL est FALSE si A n'est pas NULL.

Cet opérateur est utile lorsque vous devez comparer des colonnes qui peuvent contenir des NULL, et que vous souhaitez que NULL = NULL soit évalué comme TRUE. Exemple : Comparer deux champs qui peuvent être NULL :

SELECT champ1, champ2, (champ1 <=> champ2) AS sont_identiques
FROM ma_table_de_donnees;

3. Combinaison de Critères et de Résultats : OR vs UNION

3.1. L'opérateur logique OR

L'opérateur OR est utilisé dans la clause WHERE pour combiner plusieurs conditions, renvoyant les lignes qui satisfont au moins l'une des conditions. Il est idéal pour des filtrages complexes au sein d'une même table ou d'un même jeu de résultats.

SELECT nom_produit, prix_unitaire, categorie
FROM produits
WHERE categorie = 'Électronique' OR prix_unitaire > 500;

3.2. L'opérateur UNION

L'opérateur UNION est utilisé pour combiner les résultats de deux ou plusieurs instructions SELECT distinctes en un seul jeu de résultats. Il élimine automatiquement les lignes dupliquées (sauf si UNION ALL est utilisé). Les requêtes combinées par UNION doivent avoir le même nombre de colonnes, et les colonnes correspondantes doivent avoir des types de données compatibles.

SELECT code_client, nom_societe FROM clients_actifs
UNION
SELECT code_client, nom_societe FROM clients_potentiels;

3.3. Quand choisir entre OR et UNION ?

Bien que OR et UNION puissent parfois être utilisés pour obtenir des résultats similaires (par exemple, fusionner des lignes basées sur différents critères), leurs mécanismes internes et leurs implications en termes de performance diffèrent. Considérez cet exemple pour la table pays :

-- Utilisation de OR
SELECT nom_pays, population, superficie_km2
FROM pays
WHERE population > 50000000 OR superficie_km2 > 1000000;

-- Équivalent avec UNION
SELECT nom_pays, population, superficie_km2 FROM pays WHERE population > 50000000
UNION
SELECT nom_pays, population, superficie_km2 FROM pays WHERE superficie_km2 > 1000000;

L'opérateur OR peut parfois entraîner un scan de table complet si les colonnes impliquées dans la clause WHERE n'ont pas d'index combiné approprié. Par contre, l'utilisation de UNION permet à MySQL d'utiliser des index distincts pour chaque sous-requête, potentiellement plus efficace pour des requêtes complexes avec des index sur les colonnes filtrées. Cependant, UNION introduit un coût de tri et de déduplication des résultats (sauf avec UNION ALL), ce qui peut impacter la performance. Le choix optimal dépend souvent de la structure des index et du volume des données.

4. Élimination des Doublons : DISTINCT

Le mot-clé DISTINCT est utilisé avec l'instruction SELECT pour récupérer uniquement les valeurs uniques et non-répétées d'une ou plusieurs colonnes. Il est appliqué à l'ensemble des colonnes spécifiées.

SELECT DISTINCT nom_departement
FROM employes_departements;

Si vous sélcetionnez plusieurs colonnes avec DISTINCT, la combinaison de toutes les valeurs dans ces colonnes doit être unique pour qu'une ligne soit incluse.

SELECT DISTINCT nom_client, ville_client
FROM commandes_clients;

5. Tri des Résultats : ORDER BY

La clause ORDER BY est fondamentale pour organiser les résultats d'une requête dans un ordre spécifique. Elle permet de trier les données par une ou plusieurs colonnes, en ordre croissant (ASC, par défaut) ou décroissant (DESC).

SELECT produit_id, nom_produit, prix_vente
FROM catalogue_produits
ORDER BY prix_vente DESC, nom_produit ASC;

Dans cet exemple, les produits sont d'abord triés par prix de vente décroissant, puis, pour les produits ayant le même prix, ils sont triés par nom de produit croissant.

6. Longueur de Chaîne : CHAR_LENGTH(str) vs LENGTH(str)

En MySQL, il est essentiel de distinguer la longueur d'une chaîne en termes de nombre de caractères et en termes de nombre d'octets, surtout lorsqu'on travaille avec des jeux de caractères multi-octets comme l'UTF-8.

• CHAR_LENGTH(str) : Cette fonction retourne le nombre de caractères dans la chaîne str. Elle est la plus appropriée pour obtenir la "longueur" perçue d'une chaîne, indépendamment de la façon dont les caractères sont stockés.
• LENGTH(str) : Cette fonction retourne le nombre d'octets utilisés pour représenter la chaîne str. Pour les caractères ASCII (qui utilisent un octet par caractère en UTF-8), CHAR_LENGTH et LENGTH renverront la même valeur. Cependant, pour les caractères multi-octets (comme la plupart des caractères non-latins), LENGTH renverra une valeur supérieure à CHAR_LENGTH.

Exemple illustratif :

SELECT
    CHAR_LENGTH('SQL'),      -- Résultat: 3 (3 caractères)
    LENGTH('SQL'),           -- Résultat: 3 (3 octets en UTF-8)
    CHAR_LENGTH('Développeur'), -- Résultat: 11 (11 caractères)
    LENGTH('Développeur'),    -- Résultat: 13 (le 'é' et 'p' sont multi-octets, si config multi-octets est active, dépend du jeu de caractères)
    CHAR_LENGTH('你好世界'),  -- Résultat: 4 (4 caractères)
    LENGTH('你好世界');       -- Résultat: 12 (chaque caractère chinois prend 3 octets en UTF-8)

Il est crucial d'utiliser CHAR_LENGTH() lorsque vous souhaitez connaître le nombre de caractères visibles ou logiques d'une chaîne, par exemple pour des validations de longueur de texte, tandis que LENGTH() est plus pertinente pour des calculs liés à l'espace de stockage.